First complete draft of "getting started" guide

1 files changed, 619 insertions, 100 deletions

diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt
index fa6f398dfd..88f99e73c7 100644
--- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt
+++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt
@@ -109,19 +109,19 @@ In any case, Rails will create a folder in your working directory called +blog+.
 `-----------`-----------------------------------------------------------------------------------------------------------------------------
 File/Folder Purpose
 ------------------------------------------------------------------------------------------------------------------------------------------
-README		This is a brief instruction manual for your application. Use it to tell others what your application does, how to set it up, and so on.
-Rakefile	This file contains batch jobs that can be run from the terminal.
-app/		Contains the controllers, models, and views for your application. You'll focus on this folder for the remainder of this guide.
-config/		Configure your application's runtime rules, routes, database, and more.
-db/			Shows your current database schema, as well as the database migrations. You'll learn about migrations shortly.
-doc/		In-depth documentation for your application.
-lib/		Extended modules for your application (not covered in this guide).
-log/		Application log files.
-public/		The only folder seen to the world as-is.  This is where your images, javascript, stylesheets (CSS), and other static files go.
-script/		Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server.
-test/		Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications]
-tmp/		Temporary files
-vendor/		The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality.
++README+		This is a brief instruction manual for your application. Use it to tell others what your application does, how to set it up, and so on.
++Rakefile+	This file contains batch jobs that can be run from the terminal.
++app/+		Contains the controllers, models, and views for your application. You'll focus on this folder for the remainder of this guide.
++config/+		Configure your application's runtime rules, routes, database, and more.
++db/+			Shows your current database schema, as well as the database migrations. You'll learn about migrations shortly.
++doc/+		In-depth documentation for your application.
++lib/+		Extended modules for your application (not covered in this guide).
++log/+		Application log files.
++public/+		The only folder seen to the world as-is.  This is where your images, javascript, stylesheets (CSS), and other static files go.
++script/+		Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server.
++test/+		Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications]
++tmp/+		Temporary files
++vendor/+		The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality.
 -------------------------------------------------------------------------------------------------------------------------------------------
 
 === Configuring a SQLite Database
@@ -187,43 +187,58 @@ Change the username and password in the +development+ section as appropriate.
 
 == Getting Up and Running Quickly With Scaffolding
 
-Whenever you are dealing with a resource and you know you'll need a way to manage that resource in your application, you can start by generating a scaffold.  The reason that this guide did not start with generating the scaffold is because it is not all that useful once you are using Rails on a regular basis. For our blog, we want a "Post" resource, so let's generate that now:
+Rails _scaffolding_ is a quick way to generate some of the major pieces of an application. If you want to create the models, views, and controllers for a new resource in a single operation, scaffolding is the tool for the job. 
 
-`./script/generate scaffold Post name:string title:string content:text`
+== Creating a Resource
 
-This generates the model, controller, migration, views, tests, and routes for this resource.  It also populates these files with default data to get started.
+In the case of the blog application, I'll start by generating a scaffolded Post resource: this will represent a single blog posting. To do this, enter this command in your terminal:
 
-=== Migrations
-Database migrations make it simple to add/remove/modify tables, columns, and indexes while allowing you to roll back or forward between states with ease.
+[source, shell]
+-------------------------------------------------------
+script/generate scaffold Post name:string title:string content:text
+-------------------------------------------------------
 
-Have a look at +db/migrate/2008XXXXXXXXXX_create_posts.rb+ (Yours will have numbers specific to the time that the file was generated), which was generated when creating our Post model:
+TIP: If you're on Windows, or your Ruby is set up in some non-standard fashion, you may need to explicitly pass Rails +script+ commands to Ruby: +ruby script/generate scaffold Post name:string title:string content:text+.
 
--------------------------------------------
-class CreatePosts < ActiveRecord::Migration
-  def self.up
-    create_table :posts do |t|
+NOTE: While scaffolding will get you up and running quickly, the "one size fits all" code that it generates is unlikely to be a perfect fit for your application. In most cases, you'll need to customize the generated code. Many experienced Rails developers avoid scaffolding entirely, preferring to write all or most of their source code from scratch.
 
-      t.timestamps
-    end
-  end
+The scaffold generator will build 13 files in your application, along with some folders, and edit one more. Here's a quick overview of what it creates:
 
-  def self.down
-    drop_table :posts
-  end
-end
--------------------------------------------
+[grid="all"]
+`---------------------------------------------`--------------------------------------------------------------------------------------------
+File                                          Purpose
+------------------------------------------------------------------------------------------------------------------------------------------
+app/models/post.rb                            The Post model
+db/migrate/20081013124235_create_posts.rb     Migration to create the posts table in your database (your name will include a different timestamp)
+app/views/posts/index.html.erb                A view to display an index of all posts 
+app/views/posts/show.html.erb                 A view to display a single post
+app/views/posts/new.html.erb                  A view to create a new post
+app/views/posts/edit.html.erb                 A view to edit an existing post
+app/views/layouts/posts.html.erb              A view to control the overall look and feel of the other posts views
+public/stylesheets/scaffold.css               Cascading style sheet to make the scaffolded views look better
+app/controllers/posts_controller.rb           The Posts controller
+test/functional/posts_controller_test.rb      Functional testing harness for the posts controller
+app/helpers/posts_helper.rb                   Helper functions to be used from the posts views
+config/routes.rb                              Edited to include routing information for posts
+test/fixtures/posts.yml                       Dummy posts for use in testing
+test/unit/post_test.rb                        Unit testing harness for the posts model
+-------------------------------------------------------------------------------------------------------------------------------------------
+
+=== Running a Migration
 
-By default, Rails creates a database migration that will create the table for "posts" (plural name of model).  The +create_table+ method takes a ruby block, and by default you'll see +t.timestamps+ in there, which automatically creates and automatically handles +created_at+ and +updated_at+ datetime columns.  The +self.up+ section handles progression of the database, whereas the +self.down+ handles regression (or rollback) of the migration.
+One of the products of the +script/generate scaffold+ command is a _database migration_. Migrations are Ruby classes that are designed to make it simple to create and modify database tables. Rails uses rake commands to run migrations, and it's possible to undo a migration after it's been applied to your database. Migration filenames include a timestamp to ensure that they're processed in the order that they were created.
 
-Let's add some more columns to our migration that suit our post table.  We'll create a +name+ column for the person who wrote the post, a +title+ column for the title of the post, and a +content+ column for the actual post content.
+If you look in the +db/migrate/20081013124235_create_posts.rb+ file (remember, yours will have a slightly different name), here's what you'll find:
 
--------------------------------------------
+[source, ruby]
+-------------------------------------------------------
 class CreatePosts < ActiveRecord::Migration
   def self.up
     create_table :posts do |t|
-      t.string       :name
-      t.string       :title
-      t.text         :content
+      t.string :name
+      t.string :title
+      t.text :content
+
       t.timestamps
     end
   end
@@ -232,32 +247,61 @@ class CreatePosts < ActiveRecord::Migration
     drop_table :posts
   end
 end
--------------------------------------------
+-------------------------------------------------------
 
-Now that we have our migration just right, we can run the migration (the +self.up+ portion) by returning to the terminal and running:
+If you were to translate that into words, it says something like: when this migration is run, create a table named +posts+ with two string columns (+name+ and +title+) and a text column (+content+), and generate timestamp fields to track record creation and updating. You can learn the detailed syntax for migrations in the link:../migrations/migrations.html[Rails Database Migrations] guide.
 
-`rake db:migrate`
+At this point, you need to do two things: create the database and run the migration. You can use rake commands at the terminal for both of those tasks:
 
-This command will always run any migrations that have not yet been run.
+[source, shell]
+-------------------------------------------------------
+rake db:create
+rake db:migrate
+-------------------------------------------------------
 
-.Singular and Plural Inflections
-**************************************************************************************************************
-Rails is very smart, it knows that if you have a model "Person," the database table should be called "people".  If you have a model "Company", the database table will be called "companies".  There are a few circumstances where it will not know the correct singular and plural of a model name, but you should have no problem with this as long as you are using common English words.  Fixing these rare circumstances is beyond the scope of this guide.
-**************************************************************************************************************
+NOTE: Because you're working in the development environment by default, both of these commands will apply to the database defined in the +development+ section of your +config/database.yml+ file.
+
+=== Starting the Web Server
+
+You actually have a pretty functional Rails application already - after running only four commands! To see it, you need to start a web server on your development machine. You can do this by running another command:
+
+[source, shell]
+-------------------------------------------------------
+script/server
+-------------------------------------------------------
+
+This will fire up the lightweight Webrick web server by default. To see your application in action, open a browser window and navigate to +http://localhost:3000+. You should see Rails' default information page:
 
-First, let's make sure our database is up to date by running `rake db:migrate`.  That may generate an error if your database still has the tables from our earlier migration.  In this case, let's completely reset the database and run all migrations by running `rake db:reset`.
+image:images/rails_welcome.png[Welcome Aboard screenshot]
 
-Start up the web server with `./script/server` and point your browser to `http://localhost:3000/posts`.
+TIP: To stop the web server, hit Ctrl+C in the terminal window where it's running. In development mode, Rails does not generally require you to stop the server; changes you make in files will be automatically picked up by the server.
 
-Here you'll see an example of the instant gratification of Rails where you can completely manage the Post resource.  You'll be able to create, edit, and delete blog posts with ease.  Go ahead, try it out.
+The "Welcome Aboard" page is the smoke test for a new Rails application: it makes sure that you have your software configured correctly enough to serve a page. But you probably wanted to see something about posts. To do that, navigate to +http://localhost:3000/posts+:
 
-Now let's see how all this works.  Open up `app/controllers/posts_controller.rb`, and you'll see this time it is filled with code.
+image:images/posts_index.png[Posts Index screenshot]
 
-=== Index
+This is the result of Rails rendering the +index+ view of your posts. There aren't currently any posts in the database, but if you click the +New Post+ link you can create one. After that, you'll find that you can edit posts, look at their details, or destroy them. All of the logic and HTML to handle this was built by the single +script/generate scaffold+ command.
 
-Let's take a look at the `index` action:
+Congratulations, you're riding the rails! Now it's time to see how it all works.
 
------------------------------------------
+=== The Model
+
+The model file, +app/models/post.rb+ is about as simple as it can get:
+
+[source, ruby]
+-------------------------------------------------------
+class Post < ActiveRecord::Base
+end
+-------------------------------------------------------
+
+There isn't much to this file - but note that the +Post+ class inherits from +ActiveRecord::Base+. Active Record supplies a great deal of functionality to your Rails models for free, including basic database CRUD (Create, Read, Update, Destroy) operations, data validation, as well as sophisticated search support and the ability to relate multiple models to one another.
+
+=== Listing All Posts
+
+The easiest place to start looking at functionality is with the code that lists all posts. Open the file +app/controllers/posts_controller.rb + and look at the +index+ action:
+
+[source, ruby]
+-------------------------------------------------------
 def index
   @posts = Post.find(:all)
 
@@ -266,34 +310,56 @@ def index
     format.xml  { render :xml => @posts }
   end
 end
------------------------------------------
+-------------------------------------------------------
 
-In this action, we're setting the `@posts` instance variable to a hash of all posts in the database.  `Post.find(:all)` or `Post.all` (in Rails 2.1) calls on our model to return all the Posts in the database with no additional conditions.
+This code sets the +@posts+ instance variable to an array of all posts in the database. +Post.find(:all)+ or +Post.all+ calls the +Post+ model to return all of the posts that are currently in the database, with no limiting conditions.
 
-The `respond_to` block handles both HTML and XML calls to this action.  If we call `http://localhost:3000/posts.xml`, we'll see all our posts in XML format.  The HTML format looks for our corresponding view in `app/views/posts/index.html.erb`.  You can add any number of formats to this block to allow actions to be processed with different file types.
+TIP: For more information on finding records with Active Record, see link:../activerecord/finders.html[Active Record Finders].
 
-=== Show
+The +respond_to+ block handles both HTML and XML calls to this action. If you borwse to +http://localhost:3000/posts.xml+, you'll see all of the posts in XML format. The HTML format looks for a view in +app/views/posts/+ with a name that corresponds to the action name. Rails makes all of the instance variables from the action available to the view. Here's +app/view/posts/index.html.erb+:
 
-Back in your browser, click on the "New post" link and create your first post if you haven't done so already.  Return back to the index, and you'll see the details of your post listed, along with three actions to the right of the post: `show`, `edit`, and `destroy`.  Click the `show` link, which will bring you to the URL `http://localhost:3000/posts/1`.  Now let's look at the `show` action in `app/controllers/posts_controller.rb`:
+[source, ruby]
+-------------------------------------------------------
+<h1>Listing posts</h1>
+
+<table>
+  <tr>
+    <th>Name</th>
+    <th>Title</th>
+    <th>Content</th>
+  </tr>
+
+<% for post in @posts %>
+  <tr>
+    <td><%=h post.name %></td>
+    <td><%=h post.title %></td>
+    <td><%=h post.content %></td>
+    <td><%= link_to 'Show', post %></td>
+    <td><%= link_to 'Edit', edit_post_path(post) %></td>
+    <td><%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<% end %>
+</table>
+
+<br />
+
+<%= link_to 'New post', new_post_path %>
+-------------------------------------------------------
 
------------------------------------------
-def show
-  @post = Post.find(params[:id])
+This view iterates over the contents of the +@posts+ array to display content and links. A few things to note in the view:
 
-  respond_to do |format|
-    format.html # show.html.erb
-    format.xml  { render :xml => @post }
-  end
-end
------------------------------------------
+* +h+ is a Rails helper method to sanitize displayed data, preventing cross-site scripting attacks
+* +link_to+ builds a hyperlink to a particular destination
+* +edit_post_path+ is a helper that Rails provides as part of RESTful routing.
 
-This time, we're setting `@post` to a single record in the database that is searched for by its `id`, which is provided to the controller by the "1" in `http://localhost:3000/posts/1`.  The `show` action is ready to handle HTML or XML with the `respond_to` block:  XML can be accessed at: `http://localhost:3000/posts/1.xml`.
+TIP: For more details on the rendering process, see link:../actionview/layouts_and_rendering [Layouts and Rendering in Rails].
 
-=== New & Create
+=== Creating New Posts
 
-In your controller, you'll see the `new` and `create` actions, which are used together to create a new record.  Our `new` action simply instantiates a new Post object without any parameters:
+Creating a new post involves two actions. The first is the +new+ action, which instantiates an empty +Post+ object:
 
------------------------------------------
+[source, ruby]
+-------------------------------------------------------
 def new
   @post = Post.new
 
@@ -302,16 +368,43 @@ def new
     format.xml  { render :xml => @post }
   end
 end
-----------------------------------------
+-------------------------------------------------------
 
-Our `create` action, on the other hand, instantiates a new Post object while setting its attributes to the parameters that we specify in our form.  It then uses a `flash[:notice]` to inform the user of the status of the action.  If the Post is saved successfully, the action will redirect to the `show` action containing our new Post simply by calling the simple `redirect_to(@post)`.
+The +new.html.erb+ view displays this empty Post to the user:
 
-.The Flash
-**************************************************************************************************************
-Rails provides the Flash so that messages can be carried over to another action, providing the user with useful information on the status of their request.  In our `create` example, the user never actually sees any page rendered during the Post creation process, because it immediately redirects to the new Post as soon as the record is saved.  The Flash allows us to carry over a message to the next action, so once the user is redirected back to the `show` action, they are presented with a message saying "Post was successfully created."
-**************************************************************************************************************
+[source, ruby]
+-------------------------------------------------------
+<h1>New post</h1>
+
+<% form_for(@post) do |f| %>
+  <%= f.error_messages %>
+
+  <p>
+    <%= f.label :name %><br />
+    <%= f.text_field :name %>
+  </p>
+  <p>
+    <%= f.label :title %><br />
+    <%= f.text_field :title %>
+  </p>
+  <p>
+    <%= f.label :content %><br />
+    <%= f.text_area :content %>
+  </p>
+  <p>
+    <%= f.submit "Create" %>
+  </p>
+<% end %>
+
+<%= link_to 'Back', posts_path %>
+-------------------------------------------------------
 
-----------------------------------------
+The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed.
+
+When the user clicks the +Create+ button on this form, the browser will send information back to the +create+ method of the controller (Rails knows to call the +create+ method because the form is sent with an HTTP POST request; that's one of the conventions that I mentioned earlier):
+
+[source, ruby]
+-------------------------------------------------------
 def create
   @post = Post.new(params[:post])
 
@@ -326,54 +419,479 @@ def create
     end
   end
 end
----------------------------------------
+-------------------------------------------------------
 
-=== Edit & Update
+The +create+ action instantiates a new Post object from the data supplied by the user on the form, which Rails makes available in the +params+ hash. After saving the new post, it uses +flash[:notice]+ to create an informational message for the user, and redirects to the show action for the post. If there's any problem, the +create+ action just shows the +new+ view a second time, with any error messages.
 
-For the `edit`, `update`, and `destroy` actions, we will use the same `@post = Post.find(params[:id])` to find the appropriate record.
+.The Flash
+**************************************************************************************************************
+Rails provides the +flash+ hash (usually just called the Flash) so that messages can be carried over to another action, providing the user with useful information on the status of their request.  In the case of +create+, the user never actually sees any page rendered during the Post creation process, because it immediately redirects to the new Post as soon Rails saves the record. The Flash carries over a message to the next action, so that when the user is redirected back to the +show+ action, they are presented with a message saying "Post was successfully created."
+**************************************************************************************************************
 
-=== Destroy
+=== Showing an Individual Post
 
-Description of the destroy action
+When you click the +show+ link for a post on the index page, it will bring you to a URL like +http://localhost:3000/posts/1+. Rails interprets this as a call to the +show+ action for the resource, and passes in +1+ as the +:id+ parameter. Here's the +show+ action:
 
-== Starting the web server
-Rails comes bundled with the lightweight Webrick web server, which (like SQLite) works great in development mode, but is not designed for a production environment.  If you install Mongrel with `gem install mongrel`, Rails will use the Mongrel web server as the default instead (recommended).
-*******************
-If you're interested in alternative web servers for development and/or production, check out mod_rails (a.k.a Passenger)
-*******************
-Rails lets you run in development, test, and production environments (you can also add an unlimited number of additional environments if necessary).  In this guide, we're going to work with the development environment only, which is the default when starting the server.  From the root of your application folder, simply type the following to startup the web server:
+[source, ruby]
+-------------------------------------------------------
+def show
+  @post = Post.find(params[:id])
+
+  respond_to do |format|
+    format.html # show.html.erb
+    format.xml  { render :xml => @post }
+  end
+end
+-------------------------------------------------------
+
+The +show+ action uses +Post.find+ to search for a single record in the database by its id value. After finding the record, Rails displays it by using +show.html.erb+:
+
+[source, ruby]
+-------------------------------------------------------
+<p>
+  <b>Name:</b>
+  <%=h @post.name %>
+</p>
+
+<p>
+  <b>Title:</b>
+  <%=h @post.title %>
+</p>
+
+<p>
+  <b>Content:</b>
+  <%=h @post.content %>
+</p>
 
-`./script/server`
 
-This will start a process that allows you to connect to your application via a web browser on port 3000.  Open up a browser to +http://localhost:3000/+
+<%= link_to 'Edit', edit_post_path(@post) %> |
+<%= link_to 'Back', posts_path %>
+-------------------------------------------------------
+
+=== Editing Posts
 
-You can hit Ctrl+C anytime from the terminal to stop the web server.
+Like creating a new post, editing a post is a two-part process. The first step is a request to +edit_post_path(@post)+ with a particular post. This calls the +edit+ action in the controller:
+
+[source, ruby]
+-------------------------------------------------------
+def edit
+  @post = Post.find(params[:id])
+end
+-------------------------------------------------------
+
+After finding the requested post, Rails uses the +edit.html.erb+ view to display it:
+
+[source, ruby]
+-------------------------------------------------------
+<h1>Editing post</h1>
+
+<% form_for(@post) do |f| %>
+  <%= f.error_messages %>
+
+  <p>
+    <%= f.label :name %><br />
+    <%= f.text_field :name %>
+  </p>
+  <p>
+    <%= f.label :title %><br />
+    <%= f.text_field :title %>
+  </p>
+  <p>
+    <%= f.label :content %><br />
+    <%= f.text_area :content %>
+  </p>
+  <p>
+    <%= f.submit "Update" %>
+  </p>
+<% end %>
+
+<%= link_to 'Show', @post %> |
+<%= link_to 'Back', posts_path %>
+-------------------------------------------------------
+
+Submitting the form created by this view will invoke the +update+ action within the controller:
+
+[source, ruby]
+-------------------------------------------------------
+def update
+  @post = Post.find(params[:id])
+
+  respond_to do |format|
+    if @post.update_attributes(params[:post])
+      flash[:notice] = 'Post was successfully updated.'
+      format.html { redirect_to(@post) }
+      format.xml  { head :ok }
+    else
+      format.html { render :action => "edit" }
+      format.xml  { render :xml => @post.errors, :status => :unprocessable_entity }
+    end
+  end
+end
+-------------------------------------------------------
+
+In the +update+ action, Rails first uses the +:id+ parameter passed back from the edit view to locate the database record that's being edited. The +update_attributes+ call then takes the rest of the parameters from the request and applies them to this record. If all goes well, the user is redirected to the post's +show+ view. If there are any problems, it's back to +edit+ to correct them.
+
+NOTE: Sharp-eyed readers will have noticed that the +form_for+ declaration is identical for the +create+ and +edit+ views. Rails generates different code for the two forms because it's smart enough to notice that in the one case it's being passed a new record that has never been saved, and in the other case an existing record that has already been saved to the database.
+
+=== Destroying a Post
+
+Finally, clicking one of the +destroy+ links sends the associated id to the +destroy+ action:
+
+[source, ruby]
+-------------------------------------------------------
+def destroy
+  @post = Post.find(params[:id])
+  @post.destroy
+
+  respond_to do |format|
+    format.html { redirect_to(posts_url) }
+    format.xml  { head :ok }
+  end
+end
+-------------------------------------------------------
 
-You should see the "Welcome Aboard" default Rails screen, and can click on the "About your application's environment" link to see a brief summary of your current configuration.  If you've gotten this far, you're riding rails!  Let's dive into the code!
+The +destroy+ method of an Active Record model instance removes the corresponding record from the database. After that's done, there isn't any record to display, so Rails redirects the user's browser to the index view for the model.
 
 == Adding a Second Model
 
-== Generating a Model 
+Now that you've seen what's in a model built with scaffolding, it's time to add a second model to the application. The second model will handle comments on blog posts.
 
-Models in Rails use a singular name, and their corresponding database tables use a plural name.  In the case of our "Blog" application, we're going to need a table for our blog posts.  Because we're generating a model, we want to use the singular name:
+=== Generating a Model 
 
-`./script/generate model Post`
+Models in Rails use a singular name, and their corresponding database tables use a plural name. For the model to hold comments, the convention is to use the name Comment. Even if you don't want to use the entire apparatus set up by scaffolding, most Rails developers still use generators to make things like models and controllers. To create the new model, run this command in your terminal:
 
-You'll see that this generates several files, we're going to focus on two.  First, let's take a look at +app/models/post.rb+
+[source, shell]
+-------------------------------------------------------
+script/generate model Comment commenter:string body:text post:references
+-------------------------------------------------------
 
--------------------------------
-class Post < ActiveRecord::Base
+This command will generate four files:
+
+* +app/models/comment.rb+ - The model
+* +db/migrate/20081013214407_create_comments.rb - The migration
+* +test/unit/comment_test.rb+ and +test/fixtures/comments.yml+ - The test harness.
+
+First, take a look at +comment.rb+:
+
+[source, ruby]
+-------------------------------------------------------
+class Comment < ActiveRecord::Base
+  belongs_to :post
 end
--------------------------------
+-------------------------------------------------------
+
+This is very similar to the +post.rb+ model that you saw earlier. The difference is the line +belongs_to :post+, which sets up an Active Record _association_. You'll learn a little about associations in the next section of this guide.
 
-This is what each model you create will look like by default.  Here Rails is making the assumption that your Post model will be tied to a database, because it is telling the Post class to descend from the ActiveRecord::Base class, which is where all the database magic happens.  Let's leave the model alone for now and move onto migrations.
+In addition to the model, Rails has also made a migration to create the corresponding database table:
+
+[source, ruby]
+-------------------------------------------------------
+class CreateComments < ActiveRecord::Migration
+  def self.up
+    create_table :comments do |t|
+      t.string :commenter
+      t.text :body
+      t.references :post
+
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :comments
+  end
+end
+-------------------------------------------------------
+
+The +t.references+ line sets up a foreign key column for the association between the two models. Go ahead and run the migration:
+
+[source, shell]
+-------------------------------------------------------
+rake db:migrate
+-------------------------------------------------------
+
+Rails is smart enough to only execute the migrations that have not already been run against this particular database.
 
 === Associating Models
 
+Active Record associations let you declaratively quantify the relationship between two models. In the case of comments and posts, you could write out the relationships this way:
+
+* Each comment belongs to one post
+* One post can have many comments
+
+In fact, this is very close to the syntax that Rails uses to declare this association. You've already seen the line of code inside the Comment model that makes each comment belong to a Post:
+
+[source, ruby]
+-------------------------------------------------------
+class Comment < ActiveRecord::Base
+  belongs_to :post
+end
+-------------------------------------------------------
+
+You'll need to edit the +post.rb+ file to add the other side of the association:
+
+[source, ruby]
+-------------------------------------------------------
+class Post < ActiveRecord::Base
+  has_many :comments
+end
+-------------------------------------------------------
+
+These two declarations enable a good bit of automatic behavior. For example, if you have an instance variable +@post+ containing a post, you can retrieve all the comments belonging to that post as the array +@post.comments+.
+
+TIP: For more information on Active Record associations, see the link:../activerecord/association_basics.html+[Active Record Associations] guide.
+
+=== Adding a Route
+
+_Routes_ are entries in the +config/routes.rb+ file that tell Rails how to match incoming HTTP requests to controller actions. Open up that file and find the existing line referring to +posts+. Then edit it as follows:
+
+[source, ruby]
+-------------------------------------------------------
+map.resources :posts do |post|
+  post.resources :comments
+end
+-------------------------------------------------------
+
+This creates +comments+ as a _nested resource_ within +posts+. This is another part of capturing the hierarchical relationship that exists between posts and comments.
+
+TIP: For more information on routing, see the link:../routing/routing_outside_in[Rails Routing from the Outside In] guide.
+
 === Generating a Controller
 
+With the model in hand, you can turn your attention to creating a matching controller. Again, there's a generator for this:
+
+[source, shell]
+-------------------------------------------------------
+script/generate controller Comments index show new edit
+-------------------------------------------------------
+
+This creates seven files:
+
+* +app/controllers/comments_controller.rb+ - The controller
+* +app/helpers/comments_helper.rb - A view helper file
+* +app/views/comments/index.html.erb - The view for the index action
+* +app/views/comments/show.html.erb - The view for the show action
+* +app/views/comments/new.html.erb - The view for the new action
+* +app/views/comments/edit.html.erb - The view for the edit action
+* +test/functional/comments_controller_test.rb - The functional tests for the controller
+
+The controller will be generated with empty methods for each action that you specified in the call to +script/generate controller+:
+
+[source, ruby]
+-------------------------------------------------------
+class CommentsController < ApplicationController
+  def index
+  end
+
+  def show
+  end
+
+  def new
+  end
+
+  def edit
+  end
+
+end
+-------------------------------------------------------
+
+You'll need to flesh this out with code to actually process requests appropriately in each method. Here's a version that (for simplicity's sake) only responds to requests that require HTML:
+
+[source, ruby]
+-------------------------------------------------------
+class CommentsController < ApplicationController
+  def index
+    @post = Post.find(params[:post_id])
+    @comments = @post.comments
+  end
+
+  def show
+    @post = Post.find(params[:post_id])
+    @comment = Comment.find(params[:id])
+  end
+
+  def new
+    @post = Post.find(params[:post_id])
+    @comment = @post.comments.build
+  end
+
+  def create
+    @post = Post.find(params[:post_id])
+    @comment = @post.comments.build(params[:comment])
+    if @comment.save
+      redirect_to post_comment_path(@post, @comment)
+    else
+      render :action => "new"
+    end
+  end
+  
+  def edit
+    @post = Post.find(params[:post_id])
+    @comment = Comment.find(params[:id])
+  end
+
+  def update
+    @post = Post.find(params[:post_id])
+    @comment = Comment.find(params[:id])
+    if @comment.update_attributes(params[:comment])
+      redirect_to post_comment_path(@post, @comment)
+    else
+      render :action => "edit"
+    end
+  end
+  
+end
+-------------------------------------------------------
+
+You'll see a bit more complexity here than you did in the controller for posts. That's a side-effect of the nesting that you've set up; each request for a comment has to keep track of the post to which the comment is attached.
+
 === Building Views
 
+Because you skipped scaffolding, you'll need to build views for comments "by hand." Invoking +script/generate controller+ will give you skeleton views, but they'll be devoid of actual content. Here's a first pass at fleshing out the comment views.
+
+The +index.html.erb+ view:
+
+[source, ruby]
+-------------------------------------------------------
+<h1>Comments for <%= @post.title %></h1>
+
+<table>
+  <tr>
+    <th>Commenter</th>
+    <th>Body</th>
+  </tr>
+
+<% for comment in @comments %>
+  <tr>
+    <td><%=h comment.commenter %></td>
+    <td><%=h comment.body %></td>
+    <td><%= link_to 'Show', post_comment_path(@post, comment) %></td>
+    <td><%= link_to 'Edit', edit_post_comment_path(@post, comment) %></td>
+    <td><%= link_to 'Destroy', post_comment_path(@post, comment), :confirm => 'Are you sure?', :method => :delete %></td>
+  </tr>
+<% end %>
+</table>
+
+<br />
+
+<%= link_to 'New comment', new_post_comment_path(@post) %>
+<%= link_to 'Back to Post', @post %>
+-------------------------------------------------------
+
+The +new.html.erb+ view:
+
+[source, ruby]
+-------------------------------------------------------
+<h1>New comment</h1>
+
+<% form_for([@post, @comment]) do |f| %>
+  <%= f.error_messages %>
+
+  <p>
+    <%= f.label :commenter %><br />
+    <%= f.text_field :commenter %>
+  </p>
+  <p>
+    <%= f.label :body %><br />
+    <%= f.text_area :body %>
+  </p>
+  <p>
+    <%= f.submit "Create" %>
+  </p>
+<% end %>
+
+<%= link_to 'Back', post_comments_path(@post) %>
+-------------------------------------------------------
+
+The +show.html.erb+ view:
+
+[source, ruby]
+-------------------------------------------------------
+<h1>Comment on <%= @post.title %></h1>
+
+<p>
+  <b>Commenter:</b>
+  <%=h @comment.commenter %>
+</p>
+
+<p>
+  <b>Comment:</b>
+  <%=h @comment.body %>
+</p>
+
+<%= link_to 'Edit', edit_post_comment_path(@post, @comment) %> |
+<%= link_to 'Back', post_comments_path(@post) %>
+-------------------------------------------------------
+
+The +edit.html.erb+ view:
+
+[source, ruby]
+-------------------------------------------------------
+<h1>Editing comment</h1>
+
+<% form_for([@post, @comment]) do |f| %>
+  <%= f.error_messages %>
+
+  <p>
+    <%= f.label :commenter %><br />
+    <%= f.text_field :commenter %>
+  </p>
+  <p>
+    <%= f.label :body %><br />
+    <%= f.text_area :body %>
+  </p>
+  <p>
+    <%= f.submit "Update" %>
+  </p>
+<% end %>
+
+<%= link_to 'Show', post_comment_path(@post, @comment) %> |
+<%= link_to 'Back', post_comments_path(@post) %>
+-------------------------------------------------------
+
+Again, the added complexity here (compared to the views you saw for managing comments) comes from the necessity of juggling a post and its comments at the same time.
+
+=== Hooking Comments to Posts
+
+As a final step, I'll modify the +show.html.erb+ view for a post to show the comments on that post, and to allow managing those comments:
+
+[source, ruby]
+-------------------------------------------------------
+<p>
+  <b>Name:</b>
+  <%=h @post.name %>
+</p>
+
+<p>
+  <b>Title:</b>
+  <%=h @post.title %>
+</p>
+
+<p>
+  <b>Content:</b>
+  <%=h @post.content %>
+</p>
+
+<h2>Comments</h2>
+<% @post.comments.each do |c| %>
+	<p>
+	  <b>Commenter:</b>
+	  <%=h c.commenter %>
+	</p>
+
+	<p>
+	  <b>Comment:</b>
+	  <%=h c.body %>
+	</p>
+<% end %>
+
+<%= link_to 'Edit', edit_post_path(@post) %> |
+<%= link_to 'Back', posts_path %>
+<%= link_to 'Manage Comments', post_comments_path(@post) %>
+-------------------------------------------------------
+
+Note that each post has its own individual comments collection, accessible as +@post.comments+. That's a consequence of the declarative associations in the models. Path helpers such as +post_comments_path+ come from the nested route declaration in +config/routes.rb+.
+
 == What's Next?
 
 Now that you've seen your first Rails application, you should feel free to update it and experiment on your own. But you don't have to do everything without help. As you need assistance getting up and running with Rails, feel free to consult these support resources:
@@ -387,6 +905,7 @@ Now that you've seen your first Rails application, you should feel free to updat
 
 http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/2[Lighthouse ticket]
 
+* October 13, 2008: First complete draft by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication)
 * October 12, 2008: More detail, rearrangement, editing by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication)
 * September 8, 2008: initial version by James Miller (not yet approved for publication)