More at Overview | Download | Deploy | Code | Screencasts | Documentation | Ecosystem | Community | Blog

Getting Started with Engines

In this guide you will learn about engines and how they can be used to provide additional functionality to their host applications through a clean and very easy-to-use interface. You will learn the following things in this guide:

1 What are engines?

Engines can be considered miniature applications that provide functionality to their host applications. A Rails application is actually just a “supercharged” engine, with the Rails::Application class inheriting from Rails::Engine. Therefore, engines and applications share common functionality but are at the same time two separate beasts. Engines and applications also share a common structure, as you’ll see throughout this guide.

Engines are also closely related to plugins where the two share a common lib directory structure and are both generated using the rails plugin new generator.

The engine that will be generated for this guide will be called “blorgh”. The engine will provide blogging functionality to its host applications, allowing for new posts and comments to be created. For now, you will be working solely within the engine itself and in later sections you’ll see how to hook it into an application.

Engines can also be isolated from their host applications. This means that an application is able to have a path provided by a routing helper such as posts_path and use an engine also that provides a path also called posts_path, and the two would not clash. Along with this, controllers, models and table names are also namespaced. You’ll see how to do this later in this guide.

To see demonstrations of other engines, check out Devise, an engine that provides authentication for its parent applications, or Forem, an engine that provides forum functionality.

Finally, engines would not have be possible without the work of James Adam, Piotr Sarnacki, the Rails Core Team, and a number of other people. If you ever meet them, don’t forget to say thanks!

2 Generating an engine

To generate an engine with Rails 3.1, you will need to run the plugin generator and pass it the --mountable option. To generate the beginnings of the “blorgh” engine you will need to run this command in a terminal:

$ rails plugin new blorgh --mountable

The --mountable option tells the plugin generator that you want to create an engine (which is a mountable plugin, hence the option name), creating the basic directory structure of an engine by providing things such as the foundations of an app folder, as well a config/routes.rb file. This generator also provides a file at lib/blorgh/engine.rb which is identical in function to an application’s config/application.rb file.

2.1 Inside an engine

2.1.1 Critical files

At the root of the engine’s directory, lives a blorgh.gemspec file. When you include the engine into the application later on, you will do so with this line in a Rails application’s Gemfile:

gem 'blorgh', :path => "vendor/engines/blorgh"

By specifying it as a gem within the Gemfile, Bundler will load it as such, parsing this blorgh.gemspec file and requiring a file within the lib directory called lib/blorgh.rb. This file requires the blorgh/engine.rb file (located at lib/blorgh/engine.rb) and defines a base module called Blorgh.

require "blorgh/engine"

module Blorgh

Within lib/blorgh/engine.rb is the base class for the engine:

module Blorgh
  class Engine < Rails::Engine
    isolate_namespace Blorgh

By inheriting from the Rails::Engine class, this engine gains all the functionality it needs, such as being able to serve requests to its controllers.

The isolate_namespace method here deserves special notice. This call is responsible for isolating the controllers, models, routes and other things into their own namespace. Without this, there is a possibility that the engine’s components could “leak” into the application, causing unwanted disruption. It is recommended that this line be left within this file.

2.1.2 app directory

Inside the app directory there lives the standard assets, controllers, helpers, mailers, models and views directories that you should be familiar with from an application. The helpers, mailers and models directories are empty and so aren’t described in this section. We’ll look more into models in a future section.

Within the app/assets directory, there is the images, javascripts and stylesheets directories which, again, you should be familiar with due to their similarities of an application. One difference here however is that each directory contains a sub-directory with the engine name. Because this engine is going to be namespaced, its assets should be too.

Within the app/controllers directory there is a blorgh directory and inside that a file called application_controller.rb. This file will provide any common functionality for the controllers of the engine. The blorgh directory is where the other controllers for the engine will go. By placing them within this namespaced directory, you prevent them from possibly clashing with identically-named controllers within other engines or even within the application.

Lastly, the app/views directory contains a layouts folder which contains file at blorgh/application.html.erb which allows you to specify a layout for the engine. If this engine is to be used as a stand-alone engine, then you would add any customization to its layout in this file, rather than the applications app/views/layouts/application.html.erb file.

2.1.3 script directory

This directory contains one file, script/rails, which allows you to use the rails sub-commands and generators just like you would within an application. This means that you will very easily be able to generate new controllers and models for this engine.

2.1.4 test directory

The test directory is where tests for the engine will go. To test the engine, there is a cut-down version of a Rails application embedded within it at test/dummy. This application will mount the engine in the test/dummy/config/routes.rb file:

Rails.application.routes.draw do

  mount Blorgh::Engine => "/blorgh"

This line mounts the engine at the path of /blorgh, which will make it accessible through the application only at that path. We will look more into mounting an engine after some features have been developed.

Also in the test directory is the test/integration directory, where integration tests for the engine should be placed.

3 Providing engine functionality

The engine that this guide covers will provide posting and commenting functionality and follows a similar thread to the Getting Started Guide, with some new twists.

3.1 Generating a post resource

The first thing to generate for a blog engine is the Post model and related controller. To quickly generate this, you can use the Rails scaffold generator.

$ rails generate scaffold post title:string text:text

This command will output this information:

invoke  active_record
create    db/migrate/[timestamp]_create_blorgh_posts.rb
create    app/models/blorgh/post.rb
invoke    test_unit
create      test/unit/blorgh/post_test.rb
create      test/fixtures/blorgh/posts.yml
 route  resources :posts
invoke  scaffold_controller
create    app/controllers/blorgh/posts_controller.rb
invoke    erb
create      app/views/blorgh/posts
create      app/views/blorgh/posts/index.html.erb
create      app/views/blorgh/posts/edit.html.erb
create      app/views/blorgh/posts/show.html.erb
create      app/views/blorgh/posts/new.html.erb
create      app/views/blorgh/posts/_form.html.erb
invoke    test_unit
create      test/functional/blorgh/posts_controller_test.rb
invoke    helper
create      app/helpers/blorgh/posts_helper.rb
invoke      test_unit
create        test/unit/helpers/blorgh/posts_helper_test.rb
invoke  assets
invoke    js
create      app/assets/javascripts/blorgh/posts.js
invoke    css
create      app/assets/stylesheets/blorgh/posts.css
invoke  css
create    app/assets/stylesheets/scaffold.css

The first thing that the scaffold generator does is invoke the active_record generator, which generates a migration and a model for the resource. Note here, however, that the migration is called create_blorgh_posts rather than the usual create_posts. This is due to the isolate_namespace method called in the Blorgh::Engine class’s definition. The model here is also namespaced, being placed at app/models/blorgh/post.rb rather than app/models/post.rb.

Next, the test_unit generator is invoked for this model, generating a unit test at test/unit/blorgh/post_test.rb (rather than test/unit/post_test.rb) and a fixture at test/fixtures/blorgh/posts.yml (rather than test/fixtures/posts.yml).

After that, a line for the resource is inserted into the config/routes.rb file for the engine. This line is simply resources :posts, turning the config/routes.rb file into this:

Blorgh::Engine.routes.draw do
  resources :posts


Note here that the routes are drawn upon the Blorgh::Engine object rather than the YourApp::Application class. This is so that the engine routes are confined to the engine itself and can be mounted at a specific point as shown in the test directory section.

Next, the scaffold_controller generator is invoked, generating a controlled called Blorgh::PostsController (at app/controllers/blorgh/posts_controller.rb) and its related views at app/views/blorgh/posts. This generator also generates a functional test for the controller (test/functional/blorgh/posts_controller_test.rb) and a helper (app/helpers/blorgh/posts_controller.rb).

Everything this generator has generated is neatly namespaced. The controller’s class is defined within the Blorgh module:

module Blorgh
  class PostsController < ApplicationController

The ApplicationController class being inherited from here is the Blorgh::ApplicationController, not an application’s ApplicationController.

The helper is also namespaced:

module Blorgh
  class PostsHelper

This helps prevent conflicts with any other engine or application that may have a post resource also.

Finally, two files that are the assets for this resource are generated, app/assets/javascripts/blorgh/posts.js and app/assets/javascripts/blorgh/posts.css. You’ll see how to use these a little later.

By default, the scaffold styling is not applied to the engine as the engine’s layout file, app/views/blorgh/application.html.erb doesn’t load it. To make this apply, insert this line into the tag of this layout:

<%= stylesheet_link_tag "scaffold" %>

You can see what the engine has so far by running rake db:migrate at the root of our engine to run the migration generated by the scaffold generator, and then running rails server. When you open http://localhost:3000/blorgh/posts you will see the default scaffold that has been generated.

Blank engine scaffold

Click around! You’ve just generated your first engine’s first functions.

If you’d rather play around in the console, rails console will also work just like a Rails application. Remember: the Post model is namespaced, so to reference it you must call it as Blorgh::Post.

>> Blorgh::Post.find(1)
  => #<Blorgh::Post id: 1 ...>

One final thing is that the posts resource for this engine should be the root of the engine. Whenever someone goes to the root path where the engine is mounted, they should be shown a list of posts. This can be made to happen if this line is inserted into the config/routes.rb file inside the engine:

root :to => "posts#index"

Now people will only need to go to the root of the engine to see all the posts, rather than visiting /posts.

3.2 Generating a comments resource

Now that the engine has the ability to create new blog posts, it only makes sense to add commenting functionality as well. To do get this, you’ll need to generate a comment model, a comment controller and then modify the posts scaffold to display comments and allow people to create new ones.

Run the model generator and tell it to generate a Comment model, with the related table having two columns: a post_id integer and text text column.

$ rails generate model Comment post_id:integer text:text

This will output the following:

invoke  active_record
create    db/migrate/[timestamp]_create_blorgh_comments.rb
create    app/models/blorgh/comment.rb
invoke    test_unit
create      test/unit/blorgh/comment_test.rb
create      test/fixtures/blorgh/comments.yml

This generator call will generate just the necessary model files it needs, namespacing the files under a blorgh directory and creating a model class called Blorgh::Comment.

To show the comments on a post, edit app/views/posts/show.html.erb and add this line before the “Edit” link:

<%= render @post.comments %>

This line will require there to be a has_many association for comments defined on the Blorgh::Post model, which there isn’t right now. To define one, open app/models/blorgh/post.rb and add this line into the model:

has_many :comments

Turning the model into this:

module Blorgh
  class Post < ActiveRecord::Base
    has_many :comments

Because the has_many is defined inside a class that is inside the Blorgh module, Rails will know that you want to use the Blorgh::Comment model for these objects.

Next, there needs to be a form so that comments can be created on a post. To add this, put this line underneath the call to render @post.comments in app/views/blorgh/posts/show.html.erb:

<%= render "blorgh/comments/form" %>

Next, the partial that this line will render needs to exist. Create a new directory at app/views/blorgh/comments and in it a new file called _form.html.erb which has this content to create the required partial:

<h3>New comment</h3>
<%= form_for [@post,] do |f| %>
    <%= f.label :text %><br />
    <%= f.text_area :text %>
  <%= f.submit %>
<% end %>

This form, when submitted, is going to attempt to post to a route of posts/:post_id/comments within the engine. This route doesn’t exist at the moment, but can be created by changing the resources :posts line inside config/routes.rb into these lines:

resources :posts do
  resources :comments

The route now will exist, but the controller that this route goes to does not. To create it, run this command:

$ rails g controller comments

This will generate the following things:

create  app/controllers/blorgh/comments_controller.rb
invoke  erb
 exist    app/views/blorgh/comments
invoke  test_unit
create    test/functional/blorgh/comments_controller_test.rb
invoke  helper
create    app/helpers/blorgh/comments_helper.rb
invoke    test_unit
create      test/unit/helpers/blorgh/comments_helper_test.rb
invoke  assets
invoke    js
create      app/assets/javascripts/blorgh/comments.js
invoke    css
create      app/assets/stylesheets/blorgh/comments.css

The form will be making a POST request to /posts/:post_id/comments, which will correspond with the create action in Blorgh::CommentsController. This action needs to be created and can be done by putting the following lines inside the class definition in app/controllers/blorgh/comments_controller.rb:

def create
  @post = Post.find(params[:post_id])
  @comment =[:comment])
  flash[:notice] = "Comment has been created!"
  redirect_to post_path

This is the final part required to get the new comment form working. Displaying the comments however, is not quite right yet. If you were to create a comment right now you would see this error:

Missing partial blorgh/comments/comment with {:handlers=>[:erb, :builder], :formats=>[:html], :locale=>[:en, :en]}. Searched in:
  • “/Users/ryan/Sites/side_projects/blorgh/test/dummy/app/views”
  • “/Users/ryan/Sites/side_projects/blorgh/app/views”

The engine is unable to find the partial required for rendering the comments. Rails has looked firstly in the application’s (test/dummy) app/views directory and then in the engine’s app/views directory. When it can’t find it, it will throw this error. The engine knows to look for blorgh/comments/comment because the model object it is receiving is from the Blorgh::Comment class.

This partial will be responsible for rendering just the comment text, for now. Create a new file at app/views/blorgh/comments/_comment.html.erb and put this line inside it:

<%= comment_counter + 1 %>. <%= comment.text %>

The comment_counter local variable is given to us by the <%= render @post.comments %> call, as it will define this automatically and increment the counter as it iterates through each comment. It’s used in this example to display a small number next to each comment when it’s created.

That completes the comment function of the blogging engine. Now it’s time to use it within an application.

4 Hooking into an application

Using an engine within an application is very easy. This section covers how to mount the engine into an application and the initial setup required for it, as well as linking the engine to a User class provided by the application to provide ownership for posts and comments within the engine.

4.1 Mounting the engine

First, the engine needs to be specified inside the application’s Gemfile. If there isn’t an application handy to test this out in, generate one using the rails new command outside of the engine directory like this:

$ rails new unicorn

Usually, specifying the engine inside the Gemfile would be done by specifying it as a normal, everyday gem.

gem 'devise'

Because the blorgh engine is still under development, it will need to have a :path option for its Gemfile specification:

gem 'blorgh', :path => "/path/to/blorgh"

If the whole blorgh engine directory is copied to vendor/engines/blorgh then it could be specified in the Gemfile like this:

gem 'blorgh', :path => "vendor/engines/blorgh"

As described earlier, by placing the gem in the Gemfile it will be loaded when Rails is loaded, as it will first require lib/blorgh.rb in the engine and then lib/blorgh/engine.rb, which is the file that defines the major pieces of functionality for the engine.

To make the engine’s functionality accessible from within an application, it needs to be mounted in that application’s config/routes.rb file:

mount Blorgh::Engine, :at => "blog"

This line will mount the engine at blog in the application. Making it accessible at http://localhost:3000/blog when the application runs with rails s.

Other engines, such as Devise, handle this a little differently by making you specify custom helpers such as devise_for in the routes. These helpers do exactly the same thing, mounting pieces of the engines’s functionality at a pre-defined path which may be customizable.

4.2 Engine setup

The engine contains migrations for the blorgh_posts and blorgh_comments table which need to be created in the application’s database so that the engine’s models can query them correctly. To copy these migrations into the application use this command:

$ rake blorgh:install:migrations

This command, when run for the first time will copy over all the migrations from the engine. When run the next time, it will only copy over migrations that haven’t been copied over already. The first run for this command will output something such as this:

Copied migration [timestamp_1]_create_blorgh_posts.rb from blorgh
Copied migration [timestamp_2]_create_blorgh_comments.rb from blorgh

The first timestamp (\[timestamp_1\]) will be the current time and the second timestamp (\[timestamp_2\]) will be the current time plus a second. The reason for this is so that the migrations for the engine are run after any existing migrations in the application.

To run these migrations within the context of the application, simply run rake db:migrate. When accessing the engine through http://localhost:3000/blog, the posts will be empty. This is because the table created inside the application is different from the one created within the engine. Go ahead, play around with the newly mounted engine. You’ll find that it’s the same as when it was only an engine.

4.3 Using a class provided by the application

When an engine is created, it may want to use specific classes from an application to provide links between the pieces of the engine and the pieces of the application. In the case of the blorgh engine, making posts and comments have authors would make a lot of sense.

Usually, an application would have a User class that would provide the objects that would represent the posts’ and comments’ authors, but there could be a case where the application calls this class something different, such as Person. It’s because of this reason that the engine should not hardcode the associations to be exactly for a User class, but should allow for some flexibility around what the class is called.

To keep it simple in this case, the application will have a class called User which will represent the users of the application. It can be generated using this command:

rails g model user name:string

The rake db:migrate command needs to be run here to ensure that our application has the users table for future use.

Also to keep it simple, the posts form will have a new text field called author_name_ where users can elect to put their name. The engine will then take this name and create a new User object from it or find one that already has that name, and then associate the post with it.

First, the author_name text field needs to be added to the app/views/blorgh/posts/_form.html.erb partial inside the engine. This can be added above the title field with this code:

<div class="field">
  <%= f.label :author_name %><br />
  <%= f.text_field :author_name %>

The Blorgh::Post model should then have some code to convert the author_name field into an actual User object and associate it as that post’s author before the post is saved. It will also need to have an attr_accessor setup for this field so that the setter and getter methods are defined for it.

To do all this, you’ll need to add the attr_accessor for author_name, the association for the author and the before_save call into app/models/blorgh/post.rb. The author association will be hard-coded to the User class for the time being.

attr_accessor :author_name
belongs_to :author, :class_name => "User"

before_save :set_author

  def set_author = User.find_or_create_by_name(author_name)

By defining that the author association’s object is represented by the User class a link is established between the engine and the application. There needs to be a way of associating the records in the blorgh_posts table with the records in the users table. Because the association is called author, there should be an author_id column added to the blorgh_posts table.

To generate this new column, run this command within the engine:

$ rails g migration add_author_id_to_blorgh_posts author_id:integer

Due to the migration’s name and the column specification after it, Rails will automatically know that you want to add a column to a specific table and write that into the migration for you. You don’t need to tell it any more than this.

This migration will need to be run on the application. To do that, it must first be copied using this command:

$ rake blorgh:install:migrations

Notice here that only one migration was copied over here. This is because the first two migrations were copied over the first time this command was run.

NOTE: Migration [timestamp]_create_blorgh_posts.rb from blorgh has been skipped. Migration with the same name already exists.
  NOTE: Migration [timestamp]_create_blorgh_comments.rb from blorgh has been skipped. Migration with the same name already exists.
  Copied migration [timestamp]_add_author_id_to_blorgh_posts.rb from blorgh

Run this migration using this command:

$ rake db:migrate

Now with all the pieces in place, an action will take place that will associate an author — represented by a record in the users table — with a post, represented by the blorgh_posts table from the engine.

Finally, the author’s name should be displayed on the post’s page. Add this code above the “Title” output inside app/views/blorgh/posts/show.html.erb:

  <%= %>

For posts created previously, this will break the show page for them. We recommend deleting these posts and starting again, or manually assigning an author using rails c.

By outputting using the <%= tag the to_s method will be called on the object. By default, this will look quite ugly:


This is undesirable and it would be much better to have the user’s name there. To do this, add a to_s method to the User class within the application:

def to_s

Now instead of the ugly Ruby object output the author’s name will be displayed.

4.4 Configuring an engine

This section covers firstly how you can make the user_class setting of the Blorgh engine configurable, followed by general configuration tips for the engine.

4.4.1 Setting configuration settings in the application

The next step is to make the class that represents a User in the application customizable for the engine. This is because, as explained before, that class may not always be User. To make this customizable, the engine will have a configuration setting called user_class that will be used to specify what the class representing users is inside the application.

To define this configuration setting, you should use a mattr_accessor inside the Blorgh module for the engine, located at lib/blorgh.rb inside the engine. Inside this module, put this line:

mattr_accessor :user_class

This method works like its brothers attr_accessor and cattr_accessor, but provides a setter and getter method on the module with the specified name. To use it, it must be referenced using Blorgh.user_class.

The next step is switching the Blorgh::Post model over to this new setting. For the belongs_to association inside this model (app/models/blorgh/post.rb), it will now become this:

belongs_to :author, :class_name => Blorgh.user_class

The set_author method also located in this class should also use this class: = Blorgh.user_class.constantize.find_or_create_by_name(author_name)

To set this configuration setting within the application, an initializer should be used. By using an initializer, the configuration will be set up before the application starts and makes references to the classes of the engine which may depend on this configuration setting existing.

Create a new initializer at config/initializers/blorgh.rb inside the application where the blorgh engine is installed and put this content in it:

Blorgh.user_class = "User"

It’s very important here to use the String version of the class, rather than the class itself. If you were to use the class, Rails would attempt to load that class and then reference the related table, which could lead to problems if the table wasn’t already existing. Therefore, a String should be used and then converted to a class using constantize in the engine later on.

Go ahead and try to create a new post. You will see that it works exactly in the same way as before, except this time the engine is using the configuration setting in config/initializers/blorgh.rb to learn what the class is.

There are now no strict dependencies on what the class is, only what the class’s API must be. The engine simply requires this class to define a find_or_create_by_name method which returns an object of that class to be associated with a post when it’s created.

4.4.2 General engine configuration

Within an engine, there may come a time where you wish to use things such as initializers, internationalization or other configuration options. The great news is that these things are entirely possible because a Rails engine shares much the same functionality as a Rails application. In fact, a Rails application’s functionality is actually a superset of what is provided by engines!

If you wish to use initializers (code that should run before the engine is loaded), the best place for them is the config/initializers folder. This directory’s functionality is explained in the Initializers section of the Configuring guide.

For locales, simply place the locale files in the config/locales directory, just like you would in an application.

5 Extending engine functionality

This section looks at overriding or adding functionality to the views, controllers and models provided by an engine.

5.1 Overriding views

When Rails looks for a view to render, it will first look in the app/views directory of the application. If it cannot find the view there, then it will check in the app/views directories of all engines which have this directory.

In the blorgh engine, there is a currently a file at app/views/blorgh/posts/index.html.erb. When the engine is asked to render the view for Blorgh::PostsController’s index action, it will first see if it can find it at app/views/blorgh/posts/index.html.erb within the application and then if it cannot it will look inside the engine.

By overriding this view in the application, by simply creating a new file at app/views/blorgh/posts/index.html.erb, you can completely change what this view would normally output.

Try this now by creating a new file at app/views/blorgh/posts/index.html.erb and put this content in it:

<%= link_to "New Post", new_post_path %>
<% @posts.each do |post| %>
  <h2><%= post.title %></h2>
  <small>By <%= %></small>
  <%= simple_format(post.text) %>
<% end %>

Rather than looking like the default scaffold, the page will now look like this:

Engine scaffold overriden

5.2 Controllers

TODO: Explain how to extend a controller. IDEA: I like Devise’s devise :controllers => { "sessions" => "sessions" } idea. Perhaps we could incorporate that into the guide?

5.3 Models

TODO: Explain how to extend models provided by an engine.

5.4 Routes

Within the application, you may wish to link to some area within the engine. Due to the fact that the engine’s routes are isolated (by the isolate_namespace call within the lib/blorgh/engine.rb file), you will need to prefix these routes with the engine name. This means rather than having something such as:

<%= link_to "Blog posts", posts_path %>

It needs to be written as:

<%= link_to "Blog posts", blorgh.posts_path %>

This allows for the engine and the application to both have a posts_path routing helper and to not interfere with each other. You may also reference another engine’s routes from inside an engine using this same syntax.

If you wish to reference the application inside the engine in a similar way, use the main_app helper:

<%= link_to "Home", main_app.root_path %>

TODO: Mention how to use assets within an engine? TODO: Mention how to depend on external gems, like RedCarpet.


You're encouraged to help improve the quality of this guide.

If you see any typos or factual errors you are confident to patch, please clone docrails and push the change yourself. That branch of Rails has public write access. Commits are still reviewed, but that happens after you've submitted your contribution. docrails is cross-merged with master periodically.

You may also find incomplete content, or stuff that is not up to date. Please do add any missing documentation for master. Check the Ruby on Rails Guides Guidelines for style and conventions.

If for whatever reason you spot something to fix but cannot patch it yourself, please open an issue.

And last but not least, any kind of discussion regarding Ruby on Rails documentation is very welcome in the rubyonrails-docs mailing list.