rails 4.1.16 → 4.2.0.beta1

data/guides/source/development_dependencies_install.md

@@ -100,7 +100,7 @@ For FreeBSD users, you're done with:
 
 Or compile the `databases/sqlite3` port.
 
-Get a recent version of [Bundler](http://gembundler.com/)
+Get a recent version of [Bundler](http://bundler.io/)
 
 ```bash
 $ gem install bundler
@@ -117,7 +117,7 @@ This command will install all dependencies except the MySQL and PostgreSQL Ruby
 
 NOTE: If you would like to run the tests that use memcached, you need to ensure that you have it installed and running.
 
-You can use homebrew to install memcached on OSX:
+You can use [Homebrew](http://brew.sh/) to install memcached on OSX:
 
 ```bash
 $ brew install memcached
@@ -210,6 +210,14 @@ FreeBSD users will have to run the following:
 # pkg_add -r postgresql92-client postgresql92-server
 ```
 
+You can use [Homebrew](http://brew.sh/) to install MySQL and PostgreSQL on OSX:
+
+```bash
+$ brew install mysql
+$ brew install postgresql
+```
+Follow instructions given by [Homebrew](http://brew.sh/) to start these.
+
 Or install them through ports (they are located under the `databases` folder).
 If you run into troubles during the installation of MySQL, please see
 [the MySQL documentation](http://dev.mysql.com/doc/refman/5.1/en/freebsd-installation.html).
@@ -241,20 +249,25 @@ and create the test databases:
 
 ```bash
 $ cd activerecord
-$ bundle exec rake mysql:build_databases
+$ bundle exec rake db:mysql:build
 ```
 
 PostgreSQL's authentication works differently. A simple way to set up the development environment for example is to run with your development account
+This is not needed when installed via [Homebrew](http://brew.sh).
 
 ```bash
 $ sudo -u postgres createuser --superuser $USER
 ```
+And for OS X (when installed via [Homebrew](http://brew.sh))
+```bash
+$ createuser --superuser $USER
+```
 
 and then create the test databases with
 
 ```bash
 $ cd activerecord
-$ bundle exec rake postgresql:build_databases
+$ bundle exec rake db:postgresql:build
 ```
 
 It is possible to build databases for both PostgreSQL and MySQL with

data/guides/source/documents.yaml

@@ -13,8 +13,8 @@
       url: active_record_basics.html
       description: This guide will get you started with models, persistence to database and the Active Record pattern and library.
     -
-      name: Rails Database Migrations
-      url: migrations.html
+      name: Active Record Migrations
+      url: active_record_migrations.html
       description: This guide covers how you can use Active Record migrations to alter your database in a structured and organized manner.
     -
       name: Active Record Validations
@@ -74,6 +74,10 @@
       name: Action Mailer Basics
       url: action_mailer_basics.html
       description: This guide describes how to use Action Mailer to send and receive emails.
+    -
+      name: Active Job Basics
+      url: active_job_basics.html
+      description: This guide provides you with all you need to get started in creating, enqueueing and executing background jobs.
     -
       name: Testing Rails Applications
       url: testing.html
@@ -95,11 +99,6 @@
       name: Rails Command Line Tools and Rake Tasks
       url: command_line.html
       description: This guide covers the command line tools and rake tasks provided by Rails.
-    -
-      name: Caching with Rails
-      work_in_progress: true
-      url: caching_with_rails.html
-      description: Various caching techniques provided by Rails.
     -
       name: Asset Pipeline
       url: asset_pipeline.html
@@ -163,6 +162,11 @@
       name: Upgrading Ruby on Rails
       url: upgrading_ruby_on_rails.html
       description: This guide helps in upgrading applications to latest Ruby on Rails versions.
+    -
+      name: Ruby on Rails 4.2 Release Notes
+      url: 4_2_release_notes.html
+      description: Release notes for Rails 4.2.
+      work_in_progress: true
     -
       name: Ruby on Rails 4.1 Release Notes
       url: 4_1_release_notes.html

data/guides/source/engines.md

@@ -31,27 +31,28 @@ Engines are also closely related to plugins. The two share a common `lib`
 directory structure, and are both generated using the `rails plugin new`
 generator. The difference is that an engine is considered a "full plugin" by
 Rails (as indicated by the `--full` option that's passed to the generator
-command). This guide will refer to them simply as "engines" throughout. An
-engine **can** be a plugin, and a plugin **can** be an engine.
+command). We'll actually be using the `--mountable` option here, which includes
+all the features of `--full`, and then some. This guide will refer to these 
+"full plugins" simply as "engines" throughout. An engine **can** be a plugin,
+and a plugin **can** be an engine.
 
-The engine that will be created in this guide will be called "blorgh". The
+The engine that will be created in this guide will be called "blorgh". This
 engine will provide blogging functionality to its host applications, allowing
-for new posts and comments to be created. At the beginning of this guide, you
+for new articles and comments to be created. At the beginning of this guide, you
 will be working solely within the engine itself, but 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
+`articles_path` and use an engine also that provides a path also called
+`articles_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.
 
 It's important to keep in mind at all times that the application should
 **always** take precedence over its engines. An application is the object that
-has final say in what goes on in the universe (with the universe being the
-application's environment) where the engine should only be enhancing it, rather
-than changing it drastically.
+has final say in what goes on in its environment. The engine should
+only be enhancing it, rather than changing it drastically.
 
 To see demonstrations of other engines, check out
 [Devise](https://github.com/plataformatec/devise), an engine that provides
@@ -82,8 +83,11 @@ The full list of options for the plugin generator may be seen by typing:
 $ bin/rails plugin --help
 ```
 
-The `--full` option tells the generator that you want to create an engine,
-including a skeleton structure that provides the following:
+The `--mountable` option tells the generator that you want to create a
+"mountable" and namespace-isolated engine. This generator will provide the same
+skeleton structure as would the `--full` option. The `--full` option tells the
+generator that you want to create an engine, including a skeleton structure
+that provides the following:
 
   * An `app` directory tree
   * A `config/routes.rb` file:
@@ -94,7 +98,7 @@ including a skeleton structure that provides the following:
     ```
 
   * A file at `lib/blorgh/engine.rb`, which is identical in function to a
-  * standard Rails application's `config/application.rb` file:
+    standard Rails application's `config/application.rb` file:
 
     ```ruby
     module Blorgh
@@ -103,9 +107,7 @@ including a skeleton structure that provides the following:
     end
     ```
 
-The `--mountable` option tells the generator that you want to create a
-"mountable" and namespace-isolated engine. This generator will provide the same
-skeleton structure as would the `--full` option, and will add:
+The `--mountable` option will add to the `--full` option:
 
   * Asset manifest files (`application.js` and `application.css`)
   * A namespaced `ApplicationController` stub
@@ -134,7 +136,7 @@ following to the dummy application's routes file at
 `test/dummy/config/routes.rb`:
 
 ```ruby
-mount Blorgh::Engine, at: "blorgh"
+mount Blorgh::Engine => "/blorgh"
 ```
 
 ### Inside an Engine
@@ -171,7 +173,7 @@ Within `lib/blorgh/engine.rb` is the base class for the engine:
 
 ```ruby
 module Blorgh
-  class Engine < Rails::Engine
+  class Engine < ::Rails::Engine
     isolate_namespace Blorgh
   end
 end
@@ -197,12 +199,12 @@ within the `Engine` class definition. Without it, classes generated in an engine
 **may** conflict with an application.
 
 What this isolation of the namespace means is that a model generated by a call
-to `bin/rails g model`, such as `bin/rails g model post`, won't be called `Post`, but
-instead be namespaced and called `Blorgh::Post`. In addition, the table for the
-model is namespaced, becoming `blorgh_posts`, rather than simply `posts`.
-Similar to the model namespacing, a controller called `PostsController` becomes
-`Blorgh::PostsController` and the views for that controller will not be at
-`app/views/posts`, but `app/views/blorgh/posts` instead. Mailers are namespaced
+to `bin/rails g model`, such as `bin/rails g model article`, won't be called `Article`, but
+instead be namespaced and called `Blorgh::Article`. In addition, the table for the
+model is namespaced, becoming `blorgh_articles`, rather than simply `articles`.
+Similar to the model namespacing, a controller called `ArticlesController` becomes
+`Blorgh::ArticlesController` and the views for that controller will not be at
+`app/views/articles`, but `app/views/blorgh/articles` instead. Mailers are namespaced
 as well.
 
 Finally, routes will also be isolated within the engine. This is one of the most
@@ -283,74 +285,72 @@ created in the `test` directory as well. For example, you may wish to create a
 Providing engine functionality
 ------------------------------
 
-The engine that this guide covers provides posting and commenting functionality
-and follows a similar thread to the [Getting Started
+The engine that this guide covers provides submitting articles and commenting
+functionality and follows a similar thread to the [Getting Started
 Guide](getting_started.html), with some new twists.
 
-### Generating a Post Resource
+### Generating an Article Resource
 
-The first thing to generate for a blog engine is the `Post` model and related
+The first thing to generate for a blog engine is the `Article` model and related
 controller. To quickly generate this, you can use the Rails scaffold generator.
 
 ```bash
-$ bin/rails generate scaffold post title:string text:text
+$ bin/rails generate scaffold article 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
+create    db/migrate/[timestamp]_create_blorgh_articles.rb
+create    app/models/blorgh/article.rb
 invoke    test_unit
-create      test/models/blorgh/post_test.rb
-create      test/fixtures/blorgh/posts.yml
+create      test/models/blorgh/article_test.rb
+create      test/fixtures/blorgh/articles.yml
 invoke  resource_route
- route    resources :posts
+ route    resources :articles
 invoke  scaffold_controller
-create    app/controllers/blorgh/posts_controller.rb
+create    app/controllers/blorgh/articles_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
+create      app/views/blorgh/articles
+create      app/views/blorgh/articles/index.html.erb
+create      app/views/blorgh/articles/edit.html.erb
+create      app/views/blorgh/articles/show.html.erb
+create      app/views/blorgh/articles/new.html.erb
+create      app/views/blorgh/articles/_form.html.erb
 invoke    test_unit
-create      test/controllers/blorgh/posts_controller_test.rb
+create      test/controllers/blorgh/articles_controller_test.rb
 invoke    helper
-create      app/helpers/blorgh/posts_helper.rb
-invoke      test_unit
-create        test/helpers/blorgh/posts_helper_test.rb
+create      app/helpers/blorgh/articles_helper.rb
 invoke  assets
 invoke    js
-create      app/assets/javascripts/blorgh/posts.js
+create      app/assets/javascripts/blorgh/articles.js
 invoke    css
-create      app/assets/stylesheets/blorgh/posts.css
+create      app/assets/stylesheets/blorgh/articles.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
+however, that the migration is called `create_blorgh_articles` rather than the
+usual `create_articles`. 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` due
+being placed at `app/models/blorgh/article.rb` rather than `app/models/article.rb` due
 to the `isolate_namespace` call within the `Engine` class.
 
 Next, the `test_unit` generator is invoked for this model, generating a model
-test at `test/models/blorgh/post_test.rb` (rather than
-`test/models/post_test.rb`) and a fixture at `test/fixtures/blorgh/posts.yml`
-(rather than `test/fixtures/posts.yml`).
+test at `test/models/blorgh/article_test.rb` (rather than
+`test/models/article_test.rb`) and a fixture at `test/fixtures/blorgh/articles.yml`
+(rather than `test/fixtures/articles.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
+for the engine. This line is simply `resources :articles`, turning the
 `config/routes.rb` file for the engine into this:
 
 ```ruby
 Blorgh::Engine.routes.draw do
-  resources :posts
+  resources :articles
 end
 ```
 
@@ -362,18 +362,18 @@ be isolated from those routes that are within the application. The
 [Routes](#routes) section of this guide describes it in detail.
 
 Next, the `scaffold_controller` generator is invoked, generating a controller
-called `Blorgh::PostsController` (at
-`app/controllers/blorgh/posts_controller.rb`) and its related views at
-`app/views/blorgh/posts`. This generator also generates a test for the
-controller (`test/controllers/blorgh/posts_controller_test.rb`) and a helper
-(`app/helpers/blorgh/posts_controller.rb`).
+called `Blorgh::ArticlesController` (at
+`app/controllers/blorgh/articles_controller.rb`) and its related views at
+`app/views/blorgh/articles`. This generator also generates a test for the
+controller (`test/controllers/blorgh/articles_controller_test.rb`) and a helper
+(`app/helpers/blorgh/articles_controller.rb`).
 
 Everything this generator has created is neatly namespaced. The controller's
 class is defined within the `Blorgh` module:
 
 ```ruby
 module Blorgh
-  class PostsController < ApplicationController
+  class ArticlesController < ApplicationController
     ...
   end
 end
@@ -382,22 +382,22 @@ end
 NOTE: The `ApplicationController` class being inherited from here is the
 `Blorgh::ApplicationController`, not an application's `ApplicationController`.
 
-The helper inside `app/helpers/blorgh/posts_helper.rb` is also namespaced:
+The helper inside `app/helpers/blorgh/articles_helper.rb` is also namespaced:
 
 ```ruby
 module Blorgh
-  module PostsHelper
+  module ArticlesHelper
     ...
   end
 end
 ```
 
 This helps prevent conflicts with any other engine or application that may have
-a post resource as well.
+an article resource as well.
 
 Finally, the assets for this resource are generated in two files:
-`app/assets/javascripts/blorgh/posts.js` and
-`app/assets/stylesheets/blorgh/posts.css`. You'll see how to use these a little
+`app/assets/javascripts/blorgh/articles.js` and
+`app/assets/stylesheets/blorgh/articles.css`. You'll see how to use these a little
 later.
 
 By default, the scaffold styling is not applied to the engine because the
@@ -412,46 +412,46 @@ tag of this layout:
 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` in `test/dummy`. When you open
-`http://localhost:3000/blorgh/posts` you will see the default scaffold that has
+`http://localhost:3000/blorgh/articles` you will see the default scaffold that has
 been generated. 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`.
+like a Rails application. Remember: the `Article` model is namespaced, so to
+reference it you must call it as `Blorgh::Article`.
 
 ```ruby
->> Blorgh::Post.find(1)
-=> #<Blorgh::Post id: 1 ...>
+>> Blorgh::Article.find(1)
+=> #<Blorgh::Article id: 1 ...>
 ```
 
-One final thing is that the `posts` resource for this engine should be the root
+One final thing is that the `articles` 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
+mounted, they should be shown a list of articles. This can be made to happen if
 this line is inserted into the `config/routes.rb` file inside the engine:
 
 ```ruby
-root to: "posts#index"
+root to: "articles#index"
 ```
 
-Now people will only need to go to the root of the engine to see all the posts,
-rather than visiting `/posts`. This means that instead of
-`http://localhost:3000/blorgh/posts`, you only need to go to
+Now people will only need to go to the root of the engine to see all the articles,
+rather than visiting `/articles`. This means that instead of
+`http://localhost:3000/blorgh/articles`, you only need to go to
 `http://localhost:3000/blorgh` now.
 
 ### Generating a Comments Resource
 
-Now that the engine can create new blog posts, it only makes sense to add
+Now that the engine can create new articles, it only makes sense to add
 commenting functionality as well. To do this, you'll need to generate a comment
-model, a comment controller and then modify the posts scaffold to display
+model, a comment controller and then modify the articles scaffold to display
 comments and allow people to create new ones.
 
 From the application root, run the model generator. Tell it to generate a
-`Comment` model, with the related table having two columns: a `post_id` integer
+`Comment` model, with the related table having two columns: a `article_id` integer
 and `text` text column.
 
 ```bash
-$ bin/rails generate model Comment post_id:integer text:text
+$ bin/rails generate model Comment article_id:integer text:text
 ```
 
 This will output the following:
@@ -471,20 +471,20 @@ called `Blorgh::Comment`. Now run the migration to create our blorgh_comments
 table:
 
 ```bash
-$ bin/rake db:migrate
+$ rake db:migrate
 ```
 
-To show the comments on a post, edit `app/views/blorgh/posts/show.html.erb` and
+To show the comments on an article, edit `app/views/blorgh/articles/show.html.erb` and
 add this line before the "Edit" link:
 
 ```html+erb
 <h3>Comments</h3>
-<%= render @post.comments %>
+<%= render @article.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:
+on the `Blorgh::Article` model, which there isn't right now. To define one, open
+`app/models/blorgh/article.rb` and add this line into the model:
 
 ```ruby
 has_many :comments
@@ -494,7 +494,7 @@ Turning the model into this:
 
 ```ruby
 module Blorgh
-  class Post < ActiveRecord::Base
+  class Article < ActiveRecord::Base
     has_many :comments
   end
 end
@@ -505,9 +505,9 @@ NOTE: Because the `has_many` is defined inside a class that is inside the
 model for these objects, so there's no need to specify that using the
 `:class_name` option here.
 
-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`:
+Next, there needs to be a form so that comments can be created on an article. To
+add this, put this line underneath the call to `render @article.comments` in
+`app/views/blorgh/articles/show.html.erb`:
 
 ```erb
 <%= render "blorgh/comments/form" %>
@@ -519,7 +519,7 @@ directory at `app/views/blorgh/comments` and in it a new file called
 
 ```html+erb
 <h3>New comment</h3>
-<%= form_for [@post, @post.comments.build] do |f| %>
+<%= form_for [@article, @article.comments.build] do |f| %>
   <p>
     <%= f.label :text %><br>
     <%= f.text_area :text %>
@@ -529,12 +529,12 @@ directory at `app/views/blorgh/comments` and in it a new file called
 ```
 
 When this form is submitted, it is going to attempt to perform a `POST` request
-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
+to a route of `/articles/:article_id/comments` within the engine. This route doesn't
+exist at the moment, but can be created by changing the `resources :articles` line
 inside `config/routes.rb` into these lines:
 
 ```ruby
-resources :posts do
+resources :articles do
   resources :comments
 end
 ```
@@ -558,8 +558,6 @@ invoke  test_unit
 create    test/controllers/blorgh/comments_controller_test.rb
 invoke  helper
 create    app/helpers/blorgh/comments_helper.rb
-invoke    test_unit
-create      test/helpers/blorgh/comments_helper_test.rb
 invoke  assets
 invoke    js
 create      app/assets/javascripts/blorgh/comments.js
@@ -567,17 +565,17 @@ invoke    css
 create      app/assets/stylesheets/blorgh/comments.css
 ```
 
-The form will be making a `POST` request to `/posts/:post_id/comments`, which
+The form will be making a `POST` request to `/articles/:article_id/comments`, which
 will correspond with the `create` action in `Blorgh::CommentsController`. This
 action needs to be created, which can be done by putting the following lines
 inside the class definition in `app/controllers/blorgh/comments_controller.rb`:
 
 ```ruby
 def create
-  @post = Post.find(params[:post_id])
-  @comment = @post.comments.create(comment_params)
+  @article = Article.find(params[:article_id])
+  @comment = @article.comments.create(comment_params)
   flash[:notice] = "Comment has been created!"
-  redirect_to posts_path
+  redirect_to articles_path
 end
 
 private
@@ -612,7 +610,7 @@ line inside it:
 ```
 
 The `comment_counter` local variable is given to us by the `<%= render
-@post.comments %>` call, which will define it automatically and increment the
+@article.comments %>` call, which will define it 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.
 
@@ -625,7 +623,7 @@ 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, as well as
 linking the engine to a `User` class provided by the application to provide
-ownership for posts and comments within the engine.
+ownership for articles and comments within the engine.
 
 ### Mounting the Engine
 
@@ -676,20 +674,20 @@ pre-defined path which may be customizable.
 
 ### Engine setup
 
-The engine contains migrations for the `blorgh_posts` and `blorgh_comments`
+The engine contains migrations for the `blorgh_articles` 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:
 
 ```bash
-$ bin/rake blorgh:install:migrations
+$ rake blorgh:install:migrations
 ```
 
 If you have multiple engines that need migrations copied over, use
 `railties:install:migrations` instead:
 
 ```bash
-$ bin/rake railties:install:migrations
+$ rake railties:install:migrations
 ```
 
 This command, when run for the first time, will copy over all the migrations
@@ -698,7 +696,7 @@ haven't been copied over already. The first run for this command will output
 something such as this:
 
 ```bash
-Copied migration [timestamp_1]_create_blorgh_posts.rb from blorgh
+Copied migration [timestamp_1]_create_blorgh_articles.rb from blorgh
 Copied migration [timestamp_2]_create_blorgh_comments.rb from blorgh
 ```
 
@@ -709,7 +707,7 @@ 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
+articles 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.
@@ -734,17 +732,19 @@ rake db:migrate SCOPE=blorgh VERSION=0
 
 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
+the application. In the case of the `blorgh` engine, making articles and comments
 have authors would make a lot of sense.
 
 A typical application might have a `User` class that would be used to represent
-authors for a post or a comment. But there could be a case where the application
-calls this class something different, such as `Person`. For this reason, the
-engine should not hardcode associations specifically for a `User` class.
+authors for an article or a comment. But there could be a case where the
+application calls this class something different, such as `Person`. For this
+reason, the engine should not hardcode associations specifically for a `User`
+class.
 
 To keep it simple in this case, the application will have a class called `User`
-that represents the users of the application. It can be generated using this
-command inside the application:
+that represents the users of the application (we'll get into making this
+configurable further on). It can be generated using this command inside the
+application:
 
 ```bash
 rails g model user name:string
@@ -753,14 +753,14 @@ 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
+Also, to keep it simple, the articles 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 either create a new `User` object from it, or find one that
-already has that name. The engine will then associate the post with the found or
+already has that name. The engine will then associate the article with the found or
 created `User` object.
 
 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
+`app/views/blorgh/articles/_form.html.erb` partial inside the engine. This can be
 added above the `title` field with this code:
 
 ```html+erb
@@ -770,23 +770,23 @@ added above the `title` field with this code:
 </div>
 ```
 
-Next, we need to update our `Blorgh::PostController#post_params` method to
+Next, we need to update our `Blorgh::ArticleController#article_params` method to
 permit the new form parameter:
 
 ```ruby
-def post_params
-  params.require(:post).permit(:title, :text, :author_name)
+def article_params
+  params.require(:article).permit(:title, :text, :author_name)
 end
 ```
 
-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` set up
+The `Blorgh::Article` model should then have some code to convert the `author_name`
+field into an actual `User` object and associate it as that article's `author`
+before the article is saved. It will also need to have an `attr_accessor` set up
 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
+`app/models/blorgh/article.rb`. The `author` association will be hard-coded to the
 `User` class for the time being.
 
 ```ruby
@@ -803,14 +803,14 @@ private
 
 By representing the `author` association's object with 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
+of associating the records in the `blorgh_articles` 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.
+`author_id` column added to the `blorgh_articles` table.
 
 To generate this new column, run this command within the engine:
 
 ```bash
-$ bin/rails g migration add_author_id_to_blorgh_posts author_id:integer
+$ bin/rails g migration add_author_id_to_blorgh_articles author_id:integer
 ```
 
 NOTE: Due to the migration's name and the column specification after it, Rails
@@ -822,41 +822,41 @@ This migration will need to be run on the application. To do that, it must first
 be copied using this command:
 
 ```bash
-$ bin/rake blorgh:install:migrations
+$ rake blorgh:install:migrations
 ```
 
 Notice 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
+NOTE Migration [timestamp]_create_blorgh_articles.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
+[timestamp]_add_author_id_to_blorgh_articles.rb from blorgh
 ```
 
 Run the migration using:
 
 ```bash
-$ bin/rake db:migrate
+$ 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.
+an author - represented by a record in the `users` table - with an article,
+represented by the `blorgh_articles` 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`:
+Finally, the author's name should be displayed on the article's page. Add this code
+above the "Title" output inside `app/views/blorgh/articles/show.html.erb`:
 
 ```html+erb
 <p>
   <b>Author:</b>
-  <%= @post.author %>
+  <%= @article.author %>
 </p>
 ```
 
-By outputting `@post.author` using the `<%=` tag, the `to_s` method will be
+By outputting `@article.author` using the `<%=` tag, the `to_s` method will be
 called on the object. By default, this will look quite ugly:
 
 ```
@@ -925,15 +925,15 @@ 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.author_class`.
 
-The next step is to switch the `Blorgh::Post` model over to this new setting.
+The next step is to switch the `Blorgh::Article` model over to this new setting.
 Change the `belongs_to` association inside this model
-(`app/models/blorgh/post.rb`) to this:
+(`app/models/blorgh/article.rb`) to this:
 
 ```ruby
 belongs_to :author, class_name: Blorgh.author_class
 ```
 
-The `set_author` method in the `Blorgh::Post` model should also use this class:
+The `set_author` method in the `Blorgh::Article` model should also use this class:
 
 ```ruby
 self.author = Blorgh.author_class.constantize.find_or_create_by(name: author_name)
@@ -960,7 +960,7 @@ Resulting in something a little shorter, and more implicit in its behavior. The
 `author_class` method should always return a `Class` object.
 
 Since we changed the `author_class` method to return a `Class` instead of a
-`String`, we must also modify our `belongs_to` definition in the `Blorgh::Post`
+`String`, we must also modify our `belongs_to` definition in the `Blorgh::Article`
 model:
 
 ```ruby
@@ -985,14 +985,14 @@ to load that class and then reference the related table. This 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
+Go ahead and try to create a new article. 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 API for
 the class must be. The engine simply requires this class to define a
 `find_or_create_by` method which returns an object of that class, to be
-associated with a post when it's created. This object, of course, should have
+associated with an article when it's created. This object, of course, should have
 some sort of identifier by which it can be referenced.
 
 #### General Engine Configuration
@@ -1036,42 +1036,31 @@ functionality, especially controllers. This means that if you were to make a
 typical `GET` to a controller in a controller's functional test like this:
 
 ```ruby
-module Blorgh
-  class FooControllerTest < ActionController::TestCase
-    def test_index
-      get :index
-      ...
-    end
-  end
-end
+get :index
 ```
 
 It may not function correctly. This is because the application doesn't know how
 to route these requests to the engine unless you explicitly tell it **how**. To
-do this, you must set the `@routes` instance variable to the engine's route set
-in your setup code:
+do this, you must also pass the `:use_route` option as a parameter on these
+requests:
 
 ```ruby
-module Blorgh
-  class FooControllerTest < ActionController::TestCase
-    setup do
-      @routes = Engine.routes
-    end
-
-    def test_index
-      get :index
-      ...
-    end
-  end
-end
+get :index, use_route: :blorgh
 ```
 
 This tells the application that you still want to perform a `GET` request to the
 `index` action of this controller, but you want to use the engine's route to get
 there, rather than the application's one.
 
-This also ensures that the engine's URL helpers will work as expected in your
-tests.
+Another way to do this is to assign the `@routes` instance variable to `Engine.routes` in your test setup:
+
+```ruby
+setup do
+  @routes = Engine.routes
+end
+```
+
+This will also ensure url helpers for the engine will work as expected in your tests.
 
 Improving engine functionality
 ------------------------------
@@ -1118,12 +1107,12 @@ that isn't referenced by your main application.
 
 #### Implementing Decorator Pattern Using Class#class_eval
 
-**Adding** `Post#time_since_created`:
+**Adding** `Article#time_since_created`:
 
 ```ruby
-# MyApp/app/decorators/models/blorgh/post_decorator.rb
+# MyApp/app/decorators/models/blorgh/article_decorator.rb
 
-Blorgh::Post.class_eval do
+Blorgh::Article.class_eval do
   def time_since_created
     Time.current - created_at
   end
@@ -1131,20 +1120,20 @@ end
 ```
 
 ```ruby
-# Blorgh/app/models/post.rb
+# Blorgh/app/models/article.rb
 
-class Post < ActiveRecord::Base
+class Article < ActiveRecord::Base
   has_many :comments
 end
 ```
 
 
-**Overriding** `Post#summary`:
+**Overriding** `Article#summary`:
 
 ```ruby
-# MyApp/app/decorators/models/blorgh/post_decorator.rb
+# MyApp/app/decorators/models/blorgh/article_decorator.rb
 
-Blorgh::Post.class_eval do
+Blorgh::Article.class_eval do
   def summary
     "#{title} - #{truncate(text)}"
   end
@@ -1152,9 +1141,9 @@ end
 ```
 
 ```ruby
-# Blorgh/app/models/post.rb
+# Blorgh/app/models/article.rb
 
-class Post < ActiveRecord::Base
+class Article < ActiveRecord::Base
   has_many :comments
   def summary
     "#{title}"
@@ -1170,13 +1159,13 @@ class modifications, you might want to consider using [`ActiveSupport::Concern`]
 ActiveSupport::Concern manages load order of interlinked dependent modules and
 classes at run time allowing you to significantly modularize your code.
 
-**Adding** `Post#time_since_created` and **Overriding** `Post#summary`:
+**Adding** `Article#time_since_created` and **Overriding** `Article#summary`:
 
 ```ruby
-# MyApp/app/models/blorgh/post.rb
+# MyApp/app/models/blorgh/article.rb
 
-class Blorgh::Post < ActiveRecord::Base
-  include Blorgh::Concerns::Models::Post
+class Blorgh::Article < ActiveRecord::Base
+  include Blorgh::Concerns::Models::Article
 
   def time_since_created
     Time.current - created_at
@@ -1189,22 +1178,22 @@ end
 ```
 
 ```ruby
-# Blorgh/app/models/post.rb
+# Blorgh/app/models/article.rb
 
-class Post < ActiveRecord::Base
-  include Blorgh::Concerns::Models::Post
+class Article < ActiveRecord::Base
+  include Blorgh::Concerns::Models::Article
 end
 ```
 
 ```ruby
-# Blorgh/lib/concerns/models/post
+# Blorgh/lib/concerns/models/article
 
-module Blorgh::Concerns::Models::Post
+module Blorgh::Concerns::Models::Article
   extend ActiveSupport::Concern
 
   # 'included do' causes the included code to be evaluated in the
-  # context where it is included (post.rb), rather than being
-  # executed in the module's context (blorgh/concerns/models/post).
+  # context where it is included (article.rb), rather than being
+  # executed in the module's context (blorgh/concerns/models/article).
   included do
     attr_accessor :author_name
     belongs_to :author, class_name: "User"
@@ -1235,25 +1224,25 @@ 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, it will check in
 the `app/views` directories of all engines that have this directory.
 
-When the application is asked to render the view for `Blorgh::PostsController`'s
+When the application is asked to render the view for `Blorgh::ArticlesController`'s
 index action, it will first look for the path
-`app/views/blorgh/posts/index.html.erb` within the application. If it cannot
+`app/views/blorgh/articles/index.html.erb` within the application. If it cannot
 find it, it will look inside the engine.
 
 You can override this view in the application by simply creating a new file at
-`app/views/blorgh/posts/index.html.erb`. Then you can completely change what
+`app/views/blorgh/articles/index.html.erb`. Then 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`
+Try this now by creating a new file at `app/views/blorgh/articles/index.html.erb`
 and put this content in it:
 
 ```html+erb
-<h1>Posts</h1>
-<%= link_to "New Post", new_post_path %>
-<% @posts.each do |post| %>
-  <h2><%= post.title %></h2>
-  <small>By <%= post.author %></small>
-  <%= simple_format(post.text) %>
+<h1>Articles</h1>
+<%= link_to "New Article", new_article_path %>
+<% @articles.each do |article| %>
+  <h2><%= article.title %></h2>
+  <small>By <%= article.author %></small>
+  <%= simple_format(article.text) %>
   <hr>
 <% end %>
 ```
@@ -1270,30 +1259,30 @@ Routes inside an engine are drawn on the `Engine` class within
 
 ```ruby
 Blorgh::Engine.routes.draw do
-  resources :posts
+  resources :articles
 end
 ```
 
 By having isolated routes such as this, if you wish to link to an area of an
 engine from within an application, you will need to use the engine's routing
-proxy method. Calls to normal routing methods such as `posts_path` may end up
+proxy method. Calls to normal routing methods such as `articles_path` may end up
 going to undesired locations if both the application and the engine have such a
 helper defined.
 
-For instance, the following example would go to the application's `posts_path`
-if that template was rendered from the application, or the engine's `posts_path`
+For instance, the following example would go to the application's `articles_path`
+if that template was rendered from the application, or the engine's `articles_path`
 if it was rendered from the engine:
 
 ```erb
-<%= link_to "Blog posts", posts_path %>
+<%= link_to "Blog articles", articles_path %>
 ```
 
-To make this route always use the engine's `posts_path` routing helper method,
+To make this route always use the engine's `articles_path` routing helper method,
 we must call the method on the routing proxy method that shares the same name as
 the engine.
 
 ```erb
-<%= link_to "Blog posts", blorgh.posts_path %>
+<%= link_to "Blog articles", blorgh.articles_path %>
 ```
 
 If you wish to reference the application inside the engine in a similar way, use