Update guides from docrails

38 files changed, 1461 insertions, 362 deletions

diff --git a/railties/doc/guides/html/2_2_release_notes.html b/railties/doc/guides/html/2_2_release_notes.html
index c68f10ad5a..931786ef6c 100644
--- a/railties/doc/guides/html/2_2_release_notes.html
+++ b/railties/doc/guides/html/2_2_release_notes.html
@@ -407,7 +407,7 @@ More information :
 </li>

 </ul></div>

 <div class="para"><p>All told, the Guides provide tens of thousands of words of guidance for beginning and intermediate Rails developers.</p></div>

-<div class="para"><p>If you want to these generate guides locally, inside your application:</p></div>

+<div class="para"><p>If you want to generate these guides locally, inside your application:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

diff --git a/railties/doc/guides/html/actioncontroller_basics.html b/railties/doc/guides/html/actioncontroller_basics.html
index 32ddbe1f60..d58536cc37 100644
--- a/railties/doc/guides/html/actioncontroller_basics.html
+++ b/railties/doc/guides/html/actioncontroller_basics.html
@@ -199,18 +199,20 @@ ul#navMain {
 			<h2>Chapters</h2>
 			<ol>
 					<li>
-					<a href="#_what_does_a_controller_do">What does a controller do?</a>
+					<a href="#_what_does_a_controller_do">What Does a Controller do?</a>
 					</li>
 					<li>
-					<a href="#_methods_and_actions">Methods and actions</a>
+					<a href="#_methods_and_actions">Methods and Actions</a>
 					</li>
 					<li>
 					<a href="#_parameters">Parameters</a>
 						<ul>
 						
-							<li><a href="#_hash_and_array_parameters">Hash and array parameters</a></li>
+							<li><a href="#_hash_and_array_parameters">Hash and Array Parameters</a></li>
 						
-							<li><a href="#_routing_parameters">Routing parameters</a></li>
+							<li><a href="#_routing_parameters">Routing Parameters</a></li>
+						
+							<li><a href="#_tt_default_url_options_tt"><tt>default_url_options</tt></a></li>
 						
 						</ul>
 					</li>
@@ -218,9 +220,9 @@ ul#navMain {
 					<a href="#_session">Session</a>
 						<ul>
 						
-							<li><a href="#_disabling_the_session">Disabling the session</a></li>
+							<li><a href="#_disabling_the_session">Disabling the Session</a></li>
 						
-							<li><a href="#_accessing_the_session">Accessing the session</a></li>
+							<li><a href="#_accessing_the_session">Accessing the Session</a></li>
 						
 							<li><a href="#_the_flash">The flash</a></li>
 						
@@ -233,9 +235,9 @@ ul#navMain {
 					<a href="#_filters">Filters</a>
 						<ul>
 						
-							<li><a href="#_after_filters_and_around_filters">After filters and around filters</a></li>
+							<li><a href="#_after_filters_and_around_filters">After Filters and Around Filters</a></li>
 						
-							<li><a href="#_other_ways_to_use_filters">Other ways to use filters</a></li>
+							<li><a href="#_other_ways_to_use_filters">Other Ways to Use Filters</a></li>
 						
 						</ul>
 					</li>
@@ -243,12 +245,15 @@ ul#navMain {
 					<a href="#_verification">Verification</a>
 					</li>
 					<li>
-					<a href="#_the_request_and_response_objects">The request and response objects</a>
+					<a href="#_request_forgery_protection">Request Forgery Protection</a>
+					</li>
+					<li>
+					<a href="#_the_tt_request_tt_and_tt_response_tt_objects">The <tt>request</tt> and <tt>response</tt> Objects</a>
 						<ul>
 						
-							<li><a href="#_the_request">The request</a></li>
+							<li><a href="#_the_tt_request_tt_object">The <tt>request</tt> Object</a></li>
 						
-							<li><a href="#_the_response">The response</a></li>
+							<li><a href="#_the_tt_response_tt_object">The <tt>response</tt> Object</a></li>
 						
 						</ul>
 					</li>
@@ -256,28 +261,31 @@ ul#navMain {
 					<a href="#_http_basic_authentication">HTTP Basic Authentication</a>
 					</li>
 					<li>
-					<a href="#_streaming_and_file_downloads">Streaming and file downloads</a>
+					<a href="#_streaming_and_file_downloads">Streaming and File Downloads</a>
 						<ul>
 						
-							<li><a href="#_sending_files">Sending files</a></li>
+							<li><a href="#_sending_files">Sending Files</a></li>
 						
-							<li><a href="#_restful_downloads">RESTful downloads</a></li>
+							<li><a href="#_restful_downloads">RESTful Downloads</a></li>
 						
 						</ul>
 					</li>
 					<li>
-					<a href="#_parameter_filtering">Parameter filtering</a>
+					<a href="#_parameter_filtering">Parameter Filtering</a>
 					</li>
 					<li>
 					<a href="#_rescue">Rescue</a>
 						<ul>
 						
-							<li><a href="#_the_default_500_and_404_templates">The default 500 and 404 templates</a></li>
+							<li><a href="#_the_default_500_and_404_templates">The Default 500 and 404 Templates</a></li>
 						
 							<li><a href="#_tt_rescue_from_tt"><tt>rescue_from</tt></a></li>
 						
 						</ul>
 					</li>
+					<li>
+					<a href="#_changelog">Changelog</a>
+					</li>
 			</ol>
 		</div>
 		
@@ -285,24 +293,69 @@ ul#navMain {
 				<h1>Action Controller basics</h1>
 			<div id="preamble">

 <div class="sectionbody">

-<div class="para"><p>In this guide you will learn how controllers work and how they fit into the request cycle in your application. You will learn how to make use of the many tools provided by Action Controller to work with the session, cookies and filters and how to use the built-in HTTP authentication and data streaming facilities. In the end, we will take a look at some tools that will be useful once your controllers are ready and working, like how to filter sensitive parameters from the log and how to rescue and deal with exceptions that may be raised during the request.</p></div>

+<div class="para"><p>In this guide you will learn how controllers work and how they fit into the request cycle in your application. After reading this guide, you will be able to:</p></div>

+<div class="ilist"><ul>

+<li>

+<p>

+Follow the flow of a request through a controller

+</p>

+</li>

+<li>

+<p>

+Understand why and how to store data in the session or cookies

+</p>

+</li>

+<li>

+<p>

+Work with filters to execute code during request processing

+</p>

+</li>

+<li>

+<p>

+Use Action Controller's built-in HTTP authentication

+</p>

+</li>

+<li>

+<p>

+Stream data directly to the user's browser

+</p>

+</li>

+<li>

+<p>

+Filter sensitive parameters so they do not appear in the application's log

+</p>

+</li>

+<li>

+<p>

+Deal with exceptions that may be raised during request processing

+</p>

+</li>

+</ul></div>

 </div>

 </div>

-<h2 id="_what_does_a_controller_do">1. What does a controller do?</h2>

+<h2 id="_what_does_a_controller_do">1. What Does a Controller do?</h2>

 <div class="sectionbody">

 <div class="para"><p>Action Controller is the C in MVC. After routing has determined which controller to use for a request, your controller is responsible for making sense of the request and producing the appropriate output. Luckily, Action Controller does most of the groundwork for you and uses smart conventions to make this as straight-forward as possible.</p></div>

 <div class="para"><p>For most conventional RESTful applications, the controller will receive the request (this is invisible to you as the developer), fetch or save data from a model and use a view to create HTML output. If your controller needs to do things a little differently, that's not a problem, this is just the most common way for a controller to work.</p></div>

-<div class="para"><p>A controller can thus be thought of as a middle man between models and views. It makes the model data available to the view so it can display it to the user, and it saves or updates data from the user to the model.</p></div>

+<div class="para"><p>A controller can thus be thought of as a middle man between models and views. It makes the model data available to the view so it can display that data to the user, and it saves or updates data from the user to the model.</p></div>

+<div class="admonitionblock">

+<table><tr>

+<td class="icon">

+<img src="./images/icons/note.png" alt="Note" />

+</td>

+<td class="content">For more details on the routing process, see <a href="../routing_outside_in.html">Rails Routing from the Outside In</a>.</td>

+</tr></table>

+</div>

 </div>

-<h2 id="_methods_and_actions">2. Methods and actions</h2>

+<h2 id="_methods_and_actions">2. Methods and Actions</h2>

 <div class="sectionbody">

-<div class="para"><p>A controller is a Ruby class which inherits from ActionController::Base and has methods just like any other class. Usually these methods correspond to actions in MVC, but they can just as well be helpful methods which can be called by actions. When your application receives a request, the routing will determine which controller and action to run. Then an instance of that controller will be created and the method corresponding to the action (the method with the same name as the action) gets run.</p></div>

+<div class="para"><p>A controller is a Ruby class which inherits from ApplicationController and has methods just like any other class. Usually these methods correspond to actions in MVC, but they can just as well be helpful methods which can be called by actions. When your application receives a request, the routing will determine which controller and action to run. Then Rails creates an instance of that controller and runs the method corresponding to the action (the method with the same name as the action).</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

 http://www.lorenzobettini.it

 http://www.gnu.org/software/src-highlite -->

-<pre><tt><span style="font-weight: bold"><span style="color: #0000FF">class</span></span> ClientsController <span style="color: #990000">&lt;</span> ActionController<span style="color: #990000">::</span>Base

+<pre><tt><span style="font-weight: bold"><span style="color: #0000FF">class</span></span> ClientsController <span style="color: #990000">&lt;</span> ApplicationController

 

   <span style="font-style: italic"><span style="color: #9A1900"># Actions are public methods</span></span>

   <span style="font-weight: bold"><span style="color: #0000FF">def</span></span> new

@@ -321,7 +374,7 @@ private
 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

 <div class="para"><p>Private methods in a controller are also used as filters, which will be covered later in this guide.</p></div>

-<div class="para"><p>As an example, if the user goes to <tt>/clients/new</tt> in your application to add a new client, a ClientsController instance will be created and the <tt>new</tt> method will be run. Note that the empty method from the example above could work just fine because Rails will by default render the <tt>new.html.erb</tt> view unless the action says otherwise. The <tt>new</tt> method could make available to the view a <tt>@client</tt> instance variable by creating a new Client:</p></div>

+<div class="para"><p>As an example, if the user goes to <tt>/clients/new</tt> in your application to add a new client, Rails will create a ClientsController instance will be created and run the <tt>new</tt> method. Note that the empty method from the example above could work just fine because Rails will by default render the <tt>new.html.erb</tt> view unless the action says otherwise. The <tt>new</tt> method could make available to the view a <tt>@client</tt> instance variable by creating a new Client:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -332,10 +385,11 @@ http://www.gnu.org/software/src-highlite -->
 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

 <div class="para"><p>The <a href="../layouts_and_rendering.html">Layouts &amp; rendering guide</a> explains this in more detail.</p></div>

+<div class="para"><p>ApplicationController inherits from ActionController::Base, which defines a number of helpful methods. This guide will cover some of these, but if you're curious to see what's in there, you can see all of them in the API documentation or in the source itself.</p></div>

 </div>

 <h2 id="_parameters">3. Parameters</h2>

 <div class="sectionbody">

-<div class="para"><p>You will probably want to access data sent in by the user or other parameters in your controller actions. There are two kinds of parameters possible in a web application. The first are parameters that are sent as part of the URL, query string parameters. The query string is everything after "?" in the URL. The second type of parameter is usually referred to as POST data. This information usually comes from a HTML form which has been filled in by the user. It's called POST data because it can only be sent as part of an HTTP POST request. Rails does not make any distinction between query string parameters and POST parameters, and both are available in the <tt>params</tt> hash in your controller:</p></div>

+<div class="para"><p>You will probably want to access data sent in by the user or other parameters in your controller actions. There are two kinds of parameters possible in a web application. The first are parameters that are sent as part of the URL, called query string parameters. The query string is everything after "?" in the URL. The second type of parameter is usually referred to as POST data. This information usually comes from a HTML form which has been filled in by the user. It's called POST data because it can only be sent as part of an HTTP POST request. Rails does not make any distinction between query string parameters and POST parameters, and both are available in the <tt>params</tt> hash in your controller:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -343,9 +397,10 @@ http://www.lorenzobettini.it
 http://www.gnu.org/software/src-highlite -->

 <pre><tt><span style="font-weight: bold"><span style="color: #0000FF">class</span></span> ClientsController <span style="color: #990000">&lt;</span> ActionController<span style="color: #990000">::</span>Base

 

-  <span style="font-style: italic"><span style="color: #9A1900"># This action uses query string parameters because it gets run by a HTTP GET request,</span></span>

-  <span style="font-style: italic"><span style="color: #9A1900"># but this does not make any difference to the way in which the parameters are accessed.</span></span>

-  <span style="font-style: italic"><span style="color: #9A1900"># The URL for this action would look like this in order to list activated clients: /clients?status=activated</span></span>

+  <span style="font-style: italic"><span style="color: #9A1900"># This action uses query string parameters because it gets run by a HTTP</span></span>

+  <span style="font-style: italic"><span style="color: #9A1900"># GET request, but this does not make any difference to the way in which</span></span>

+  <span style="font-style: italic"><span style="color: #9A1900"># the parameters are accessed. The URL for this action would look like this</span></span>

+  <span style="font-style: italic"><span style="color: #9A1900"># in order to list activated clients: /clients?status=activated</span></span>

   <span style="font-weight: bold"><span style="color: #0000FF">def</span></span> index

     <span style="font-weight: bold"><span style="color: #0000FF">if</span></span> params<span style="color: #990000">[:</span>status<span style="color: #990000">]</span> <span style="color: #990000">=</span> <span style="color: #FF0000">"activated"</span>

       <span style="color: #009900">@clients</span> <span style="color: #990000">=</span> Client<span style="color: #990000">.</span>activated

@@ -370,11 +425,11 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<h3 id="_hash_and_array_parameters">3.1. Hash and array parameters</h3>

+<h3 id="_hash_and_array_parameters">3.1. Hash and Array Parameters</h3>

 <div class="para"><p>The params hash is not limited to one-dimensional keys and values. It can contain arrays and (nested) hashes. To send an array of values, append "[]" to the key name:</p></div>

 <div class="listingblock">

 <div class="content">

-<pre><tt>GET /clients?ids[]=1&amp;ids[2]&amp;ids[]=3</tt></pre>

+<pre><tt>GET /clients?ids[]=1&amp;ids[]=2&amp;ids[]=3</tt></pre>

 </div></div>

 <div class="para"><p>The value of <tt>params[:ids]</tt> will now be <tt>["1", "2", "3"]</tt>. Note that parameter values are always strings; Rails makes no attempt to guess or cast the type.</p></div>

 <div class="para"><p>To send a hash you include the key name inside the brackets:</p></div>

@@ -388,8 +443,32 @@ http://www.gnu.org/software/src-highlite -->
 &lt;/form&gt;</tt></pre>

 </div></div>

 <div class="para"><p>The value of <tt>params[:client]</tt> when this form is submitted  will be <tt>{:name &#8658; "Acme", :phone &#8658; "12345", :address &#8658; {:postcode &#8658; "12345", :city &#8658; "Carrot City"}}</tt>. Note the nested hash in <tt>params[:client][:address]</tt>.</p></div>

-<h3 id="_routing_parameters">3.2. Routing parameters</h3>

-<div class="para"><p>The <tt>params</tt> hash will always contain the <tt>:controller</tt> and <tt>:action</tt> keys, but you should use the methods <tt>controller_name</tt> and <tt>action_name</tt> instead to access these values. Any other parameters defined by the routing, such as <tt>:id</tt> will also be available.</p></div>

+<h3 id="_routing_parameters">3.2. Routing Parameters</h3>

+<div class="para"><p>The <tt>params</tt> hash will always contain the <tt>:controller</tt> and <tt>:action</tt> keys, but you should use the methods <tt>controller_name</tt> and <tt>action_name</tt> instead to access these values. Any other parameters defined by the routing, such as <tt>:id</tt> will also be available. As an example, consider a listing of clients where the list can show either active or inactive clients. We can add a route which captures the <tt>:status</tt> parameter in a "pretty" URL:</p></div>

+<div class="listingblock">

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="font-style: italic"><span style="color: #9A1900"># ...</span></span>

+map<span style="color: #990000">.</span>connect <span style="color: #FF0000">"/clients/:status"</span><span style="color: #990000">,</span> <span style="color: #990000">:</span>controller <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">"clients"</span><span style="color: #990000">,</span> <span style="color: #990000">:</span>action <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">"index"</span><span style="color: #990000">,</span> <span style="color: #990000">:</span>foo <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">"bar"</span>

+<span style="font-style: italic"><span style="color: #9A1900"># ...</span></span>

+</tt></pre></div></div>

+<div class="para"><p>In this case, when a user opens the URL <tt>/clients/active</tt>, <tt>params[:status]</tt> will be set to "active". When this route is used, <tt>params[:foo]</tt> will also be set to "bar" just like it was passed in the query string in the same way <tt>params[:action]</tt> will contain "index".</p></div>

+<h3 id="_tt_default_url_options_tt">3.3. <tt>default_url_options</tt></h3>

+<div class="para"><p>You can set global default parameters that will be used when generating URLs with <tt>default_url_options</tt>. To do this, define a method with that name in your controller:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>class ApplicationController &lt; ActionController::Base

+

+  #The options parameter is the hash passed in to url_for

+  def default_url_options(options)

+    {:locale =&gt; I18n.locale}

+  end

+

+end</tt></pre>

+</div></div>

+<div class="para"><p>These options will be used as a starting-point when generating, so it's possible they'll be overridden by url_for. Because this method is defined in the controller, you can define it on ApplicationController so it would be used for all URL generation, or you could define it on only one controller for all URLs generated there.</p></div>

 </div>

 <h2 id="_session">4. Session</h2>

 <div class="sectionbody">

@@ -416,8 +495,9 @@ ActiveRecordStore - Stores the data in a database using Active Record.
 </p>

 </li>

 </ul></div>

-<div class="para"><p>All session stores store the session id in a cookie - there is no other way of passing it to the server. Most stores also use this key to locate the session data on the server.</p></div>

-<div class="para"><p>The default and recommended store, the Cookie Store, does not store session data on the server, but in the cookie itself. The data is cryptographically signed to make it tamper-proof, but it is not encrypted, so anyone with access to it can read its contents. It can only store about 4kB of data - much less than the others - but this is usually enough. Storing large amounts of data is discouraged no matter which session store your application uses. Expecially discouraged is storing complex objects (anything other than basic Ruby objects, the primary example being model instances) in the session, as the server might not be able to reassemble them between requests, which will result in an error. The Cookie Store has the added advantage that it does not require any setting up beforehand - Rails will generate a "secret key" which will be used to sign the cookie when you create the application.</p></div>

+<div class="para"><p>All session stores store either the session ID or the entire session in a cookie - Rails does not allow the session ID to be passed in any other way. Most stores also use this key to locate the session data on the server.</p></div>

+<div class="para"><p>The default and recommended store, the Cookie Store, does not store session data on the server, but in the cookie itself. The data is cryptographically signed to make it tamper-proof, but it is not encrypted, so anyone with access to it can read its contents but not edit it. It can only store about 4kB of data - much less than the others - but this is usually enough. Storing large amounts of data is discouraged no matter which session store your application uses. You should especially avoid storing complex objects (anything other than basic Ruby objects, the primary example being model instances) in the session, as the server might not be able to reassemble them between requests, which will result in an error. The Cookie Store has the added advantage that it does not require any setting up beforehand - Rails will generate a "secret key" which will be used to sign the cookie when you create the application.</p></div>

+<div class="para"><p>Read more about session storage in the <a href="../security.html">Security Guide</a>.</p></div>

 <div class="para"><p>If you need a different session storage mechanism, you can change it in the <tt>config/environment.rb</tt> file:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -427,8 +507,8 @@ http://www.gnu.org/software/src-highlite -->
 <pre><tt><span style="font-style: italic"><span style="color: #9A1900"># Set to one of [:active_record_store, :drb_store, :mem_cache_store, :cookie_store]</span></span>

 config<span style="color: #990000">.</span>action_controller<span style="color: #990000">.</span>session_store <span style="color: #990000">=</span> <span style="color: #990000">:</span>active_record_store

 </tt></pre></div></div>

-<h3 id="_disabling_the_session">4.1. Disabling the session</h3>

-<div class="para"><p>Sometimes you don't need a session, and you can turn it off to avoid the unnecessary overhead. To do this, use the <a href="http://api.rubyonrails.org/classes/ActionController/SessionManagement/ClassMethods.html#M000649">session</a> class method in your controller:</p></div>

+<h3 id="_disabling_the_session">4.1. Disabling the Session</h3>

+<div class="para"><p>Sometimes you don't need a session. In this case, you can turn it off to avoid the unnecessary overhead. To do this, use the <tt>session</tt> class method in your controller:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -450,7 +530,7 @@ http://www.gnu.org/software/src-highlite -->
   session <span style="color: #990000">:</span>on

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>Or even a single action:</p></div>

+<div class="para"><p>Or even for specified actions:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -460,7 +540,7 @@ http://www.gnu.org/software/src-highlite -->
   session <span style="color: #990000">:</span>on<span style="color: #990000">,</span> <span style="color: #990000">:</span>only <span style="color: #990000">=&gt;</span> <span style="color: #990000">[:</span>create<span style="color: #990000">,</span> <span style="color: #990000">:</span>update<span style="color: #990000">]</span>

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<h3 id="_accessing_the_session">4.2. Accessing the session</h3>

+<h3 id="_accessing_the_session">4.2. Accessing the Session</h3>

 <div class="para"><p>In your controller you can access the session through the <tt>session</tt> instance method.</p></div>

 <div class="admonitionblock">

 <table><tr>

@@ -481,7 +561,7 @@ http://www.gnu.org/software/src-highlite -->
 private

 

   <span style="font-style: italic"><span style="color: #9A1900"># Finds the User with the ID stored in the session with the key :current_user_id</span></span>

-  <span style="font-style: italic"><span style="color: #9A1900"># This is a common way to do user login in a Rails application; logging in sets the</span></span>

+  <span style="font-style: italic"><span style="color: #9A1900"># This is a common way to handle user login in a Rails application; logging in sets the</span></span>

   <span style="font-style: italic"><span style="color: #9A1900"># session value and logging out removes it.</span></span>

   <span style="font-weight: bold"><span style="color: #0000FF">def</span></span> current_user

     <span style="color: #009900">@_current_user</span> <span style="color: #990000">||=</span> session<span style="color: #990000">[:</span>current_user_id<span style="color: #990000">]</span> <span style="color: #990000">&amp;&amp;</span> User<span style="color: #990000">.</span>find<span style="color: #990000">(</span>session<span style="color: #990000">[:</span>current_user_id<span style="color: #990000">])</span>

@@ -525,9 +605,9 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>To reset the entire session, use <a href="http://api.rubyonrails.org/classes/ActionController/Base.html#M000855">reset_session</a>.</p></div>

+<div class="para"><p>To reset the entire session, use <tt>reset_session</tt>.</p></div>

 <h3 id="_the_flash">4.3. The flash</h3>

-<div class="para"><p>The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for storing error messages etc. It is accessed in much the same way as the session, like a hash. Let's use the act of logging out as an example. The controller can set a message which will be displayed to the user on the next request:</p></div>

+<div class="para"><p>The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for storing error messages etc. It is accessed in much the same way as the session, like a hash. Let's use the act of logging out as an example. The controller can send a message which will be displayed to the user on the next request:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -578,7 +658,7 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<h4 id="_flash_now">4.3.1. flash.now</h4>

+<h4 id="_tt_flash_now_tt">4.3.1. <tt>flash.now</tt></h4>

 <div class="para"><p>By default, adding values to the flash will make them available to the next request, but sometimes you may want to access those values in the same request. For example, if the <tt>create</tt> action fails to save a resource and you render the <tt>new</tt> template directly, that's not going to result in a new request, but you may still want to display a message using the flash. To do this, you can use <tt>flash.now</tt> in the same way you use the normal <tt>flash</tt>:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -634,11 +714,11 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>Note that while for session values, you set the key to <tt>nil</tt>, to delete a cookie value, you use <tt>cookies.delete(:key)</tt>.</p></div>

+<div class="para"><p>Note that while for session values, you set the key to <tt>nil</tt>, to delete a cookie value, you should use <tt>cookies.delete(:key)</tt>.</p></div>

 </div>

 <h2 id="_filters">6. Filters</h2>

 <div class="sectionbody">

-<div class="para"><p>Filters are methods that are run before, after or "around" a controller action. For example, one filter might check to see if the logged in user has the right credentials to access that particular controller or action. Filters are inherited, so if you set a filter on ApplicationController, it will be run on every controller in your application. A common, simple filter is one which requires that a user is logged in for an action to be run. Let's define the filter method first:</p></div>

+<div class="para"><p>Filters are methods that are run before, after or "around" a controller action. For example, one filter might check to see if the logged in user has the right credentials to access that particular controller or action. Filters are inherited, so if you set a filter on ApplicationController, it will be run on every controller in your application. A common, simple filter is one which requires that a user is logged in for an action to be run. You can define the filter method this way:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -666,7 +746,7 @@ private
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>The method simply stores an error message in the flash and redirects to the login form if the user is not logged in. If a before filter (a filter which is run before the action) renders or redirects, the action will not run. If there are additional filters scheduled to run after the rendering/redirecting filter, they are also cancelled. To use this filter in a controller, use the <a href="http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html#M000704">before_filter</a> method:</p></div>

+<div class="para"><p>The method simply stores an error message in the flash and redirects to the login form if the user is not logged in. If a before filter (a filter which is run before the action) renders or redirects, the action will not run. If there are additional filters scheduled to run after the rendering or redirecting filter, they are also cancelled. To use this filter in a controller, use the <tt>before_filter</tt> method:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -678,7 +758,7 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>In this example, the filter is added to ApplicationController and thus all controllers in the application. This will make everything in the application require the user to be logged in in order to use it. For obvious reasons (the user wouldn't be able to log in in the first place!), not all controllers or actions should require this, so to prevent this filter from running you can use <a href="http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html#M000711">skip_before_filter</a> :</p></div>

+<div class="para"><p>In this example, the filter is added to ApplicationController and thus all controllers in the application. This will make everything in the application require the user to be logged in in order to use it. For obvious reasons (the user wouldn't be able to log in in the first place!), not all controllers or actions should require this. You can prevent this filter from running before particular actions with <tt>skip_before_filter</tt> :</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -690,8 +770,8 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>Now, the LoginsController's "new" and "create" actions will work as before without requiring the user to be logged in. The <tt>:only</tt> option is used to only skip this filter for these actions, and there is also an <tt>:except</tt> option which works the other way. These options can be used when adding filters too, so you can add a filter which only runs for selected actions in the first place.</p></div>

-<h3 id="_after_filters_and_around_filters">6.1. After filters and around filters</h3>

+<div class="para"><p>Now, the <tt>LoginsController</tt>'s "new" and "create" actions will work as before without requiring the user to be logged in. The <tt>:only</tt> option is used to only skip this filter for these actions, and there is also an <tt>:except</tt> option which works the other way. These options can be used when adding filters too, so you can add a filter which only runs for selected actions in the first place.</p></div>

+<h3 id="_after_filters_and_around_filters">6.1. After Filters and Around Filters</h3>

 <div class="para"><p>In addition to the before filters, you can run filters after an action has run or both before and after. The after filter is similar to the before filter, but because the action has already been run it has access to the response data that's about to be sent to the client. Obviously, after filters can not stop the action from running. Around filters are responsible for running the action, but they can choose not to, which is the around filter's way of stopping it.</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -715,9 +795,9 @@ private
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<h3 id="_other_ways_to_use_filters">6.2. Other ways to use filters</h3>

+<h3 id="_other_ways_to_use_filters">6.2. Other Ways to Use Filters</h3>

 <div class="para"><p>While the most common way to use filters is by creating private methods and using *_filter to add them, there are two other ways to do the same thing.</p></div>

-<div class="para"><p>The first is to use a block directly with the *_filter methods. The block receives the controller as an argument, and the <tt>require_login</tt> filter from above could be rewritte to use a block:</p></div>

+<div class="para"><p>The first is to use a block directly with the *_filter methods. The block receives the controller as an argument, and the <tt>require_login</tt> filter from above could be rewritten to use a block:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -730,7 +810,7 @@ http://www.gnu.org/software/src-highlite -->
 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

 <div class="para"><p>Note that the filter in this case uses <tt>send</tt> because the <tt>logged_in?</tt> method is private and the filter is not run in the scope of the controller. This is not the recommended way to implement this particular filter, but in more simple cases it might be useful.</p></div>

-<div class="para"><p>The second way is to use a class (actually, any object that responds to the right methods will do) to handle the filtering. This is useful in cases that are more complex than can not be implemented in a readable and reusable way using the two other methods. As an example, we will rewrite the login filter again to use a class:</p></div>

+<div class="para"><p>The second way is to use a class (actually, any object that responds to the right methods will do) to handle the filtering. This is useful in cases that are more complex than can not be implemented in a readable and reusable way using the two other methods. As an example, you could rewrite the login filter again to use a class:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -753,13 +833,13 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>Again, this is not an ideal example for this filter, because it's not run in the scope of the controller but gets it passed as an argument. The filter class has a class method <tt>filter</tt> which gets run before or after the action, depending on if it's a before or after filter. Classes used as around filters can also use the same <tt>filter</tt> method, which will get run in the same way. The method must <tt>yield</tt> to execute the action. Alternatively, it can have both a <tt>before</tt> and an <tt>after</tt> method that are run before and after the action.</p></div>

+<div class="para"><p>Again, this is not an ideal example for this filter, because it's not run in the scope of the controller but gets the controller passed as an argument. The filter class has a class method <tt>filter</tt> which gets run before or after the action, depending on if it's a before or after filter. Classes used as around filters can also use the same <tt>filter</tt> method, which will get run in the same way. The method must <tt>yield</tt> to execute the action. Alternatively, it can have both a <tt>before</tt> and an <tt>after</tt> method that are run before and after the action.</p></div>

 <div class="para"><p>The Rails API documentation has <a href="http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html">more information on using filters</a>.</p></div>

 </div>

 <h2 id="_verification">7. Verification</h2>

 <div class="sectionbody">

-<div class="para"><p>Verifications make sure certain criterias are met in order for a controller or action to run. They can specify that a certain key (or several keys in the form of an array) is present in the <tt>params</tt>, <tt>session</tt> or <tt>flash</tt> hashes or that a certain HTTP method was used or that the request was made using XMLHTTPRequest (Ajax). The default action taken when these criterias are not met is to render a 400 Bad Request response, but you can customize this by specifying a redirect URL or rendering something else and you can also add flash messages and HTTP headers to the response. It is described in the <a href="http://api.rubyonrails.org/classes/ActionController/Verification/ClassMethods.html">API codumentation</a> as "essentially a special kind of before_filter".</p></div>

-<div class="para"><p>Let's see how we can use verification to make sure the user supplies a username and a password in order to log in:</p></div>

+<div class="para"><p>Verifications make sure certain criteria are met in order for a controller or action to run. They can specify that a certain key (or several keys in the form of an array) is present in the <tt>params</tt>, <tt>session</tt> or <tt>flash</tt> hashes or that a certain HTTP method was used or that the request was made using XMLHTTPRequest (Ajax). The default action taken when these criteria are not met is to render a 400 Bad Request response, but you can customize this by specifying a redirect URL or rendering something else and you can also add flash messages and HTTP headers to the response. It is described in the <a href="http://api.rubyonrails.org/classes/ActionController/Verification/ClassMethods.html">API documentation</a> as "essentially a special kind of before_filter".</p></div>

+<div class="para"><p>Here's an example of using verification to make sure the user supplies a username and a password in order to log in:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -794,16 +874,49 @@ http://www.gnu.org/software/src-highlite -->
   verify <span style="color: #990000">:</span>params <span style="color: #990000">=&gt;</span> <span style="color: #990000">[:</span>username<span style="color: #990000">,</span> <span style="color: #990000">:</span>password<span style="color: #990000">],</span>

          <span style="color: #990000">:</span>render <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">{</span><span style="color: #990000">:</span>action <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">"new"</span><span style="color: #FF0000">}</span><span style="color: #990000">,</span>

          <span style="color: #990000">:</span>add_flash <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">{</span><span style="color: #990000">:</span>error <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">"Username and password required to log in"</span><span style="color: #FF0000">}</span><span style="color: #990000">,</span>

-         <span style="color: #990000">:</span>only <span style="color: #990000">=&gt;</span> <span style="color: #990000">:</span>create <span style="font-style: italic"><span style="color: #9A1900">#Only run this verification for the "create" action</span></span>

+         <span style="color: #990000">:</span>only <span style="color: #990000">=&gt;</span> <span style="color: #990000">:</span>create <span style="font-style: italic"><span style="color: #9A1900"># Only run this verification for the "create" action</span></span>

 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

 </div>

-<h2 id="_the_request_and_response_objects">8. The request and response objects</h2>

+<h2 id="_request_forgery_protection">8. Request Forgery Protection</h2>

 <div class="sectionbody">

-<div class="para"><p>In every controller there are two accessor methods pointing to the request and the response objects associated with the request cycle that is currently in execution. The <tt>request</tt> method contains an instance of <a href="http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html">AbstractRequest</a> and the <tt>response</tt> method contains the <a href="http://github.com/rails/rails/tree/master/actionpack/lib/action_controller/response.rb">response object</a> representing what is going to be sent back to the client.</p></div>

-<h3 id="_the_request">8.1. The request</h3>

-<div class="para"><p>The request object contains a lot of useful information about the request coming in from the client. To get a full list of the available methods, refer to the <a href="http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html">API documentation</a>.</p></div>

+<div class="para"><p>Cross-site request forgery is a type of attack in which a site tricks a user into making requests on another site, possibly adding, modifying or deleting data on that site without the user's knowledge or permission. The first step to avoid this is to make sure all "destructive" actions (create, update and destroy) can only be accessed with non-GET requests. If you're following RESTful conventions you're already doing this. However, a malicious site can still send a non-GET request to your site quite easily, and that's where the request forgery protection comes in. As the name says, it protects from forged requests. The way this is done is to add a non-guessable token which is only known to your server to each request. This way, if a request comes in without the proper token, it will be denied access.</p></div>

+<div class="para"><p>If you generate a form like this:</p></div>

+<div class="listingblock">

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="color: #FF0000">&lt;% form_for @user do |f| -%&gt;</span>

+  <span style="color: #FF0000">&lt;%= f.text_field :username %&gt;</span>

+  <span style="color: #FF0000">&lt;%= f.text_field :password -%&gt;</span>

+<span style="color: #FF0000">&lt;% end -%&gt;</span>

+</tt></pre></div></div>

+<div class="para"><p>You will see how the token gets added as a hidden field:</p></div>

+<div class="listingblock">

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="font-weight: bold"><span style="color: #0000FF">&lt;form</span></span> <span style="color: #009900">action</span><span style="color: #990000">=</span><span style="color: #FF0000">"/users/1"</span> <span style="color: #009900">method</span><span style="color: #990000">=</span><span style="color: #FF0000">"post"</span><span style="font-weight: bold"><span style="color: #0000FF">&gt;</span></span>

+<span style="font-weight: bold"><span style="color: #0000FF">&lt;div&gt;</span></span><span style="font-style: italic"><span style="color: #9A1900">&lt;!-- ... --&gt;</span></span><span style="font-weight: bold"><span style="color: #0000FF">&lt;input</span></span> <span style="color: #009900">type</span><span style="color: #990000">=</span><span style="color: #FF0000">"hidden"</span> <span style="color: #009900">value</span><span style="color: #990000">=</span><span style="color: #FF0000">"67250ab105eb5ad10851c00a5621854a23af5489"</span> <span style="color: #009900">name</span><span style="color: #990000">=</span><span style="color: #FF0000">"authenticity_token"</span><span style="font-weight: bold"><span style="color: #0000FF">/&gt;&lt;/div&gt;</span></span>

+<span style="font-style: italic"><span style="color: #9A1900">&lt;!-- Fields --&gt;</span></span>

+<span style="font-weight: bold"><span style="color: #0000FF">&lt;/form&gt;</span></span>

+</tt></pre></div></div>

+<div class="para"><p>Rails adds this token to every form that's generated using the <a href="../form_helpers.html">form helpers</a>, so most of the time you don't have to worry about it. If you're writing a form manually or need to add the token for another reason, it's available through the method <tt>form_authenticity_token</tt>:</p></div>

+<div class="listingblock">

+<div class="title">Example: Add a JavaScript variable containing the token for use with Ajax</div>

+<div class="content">

+<pre><tt>&lt;%= javascript_tag "MyApp.authenticity_token = '#{form_authenticity_token}'" %&gt;</tt></pre>

+</div></div>

+<div class="para"><p>The <a href="../security.html">Security Guide</a> has more about this and a lot of other security-related issues that you should be aware of when developing a web application.</p></div>

+</div>

+<h2 id="_the_tt_request_tt_and_tt_response_tt_objects">9. The <tt>request</tt> and <tt>response</tt> Objects</h2>

+<div class="sectionbody">

+<div class="para"><p>In every controller there are two accessor methods pointing to the request and the response objects associated with the request cycle that is currently in execution. The <tt>request</tt> method contains an instance of AbstractRequest and the <tt>response</tt> method returns a <tt>response</tt> object representing what is going to be sent back to the client.</p></div>

+<h3 id="_the_tt_request_tt_object">9.1. The <tt>request</tt> Object</h3>

+<div class="para"><p>The request object contains a lot of useful information about the request coming in from the client. To get a full list of the available methods, refer to the <a href="http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html">API documentation</a>. Among the properties that you can access on this object:</p></div>

 <div class="ilist"><ul>

 <li>

 <p>

@@ -812,7 +925,7 @@ host - The hostname used for this request.
 </li>

 <li>

 <p>

-domain - The hostname without the first part (usually "www").

+domain - The hostname without the first segment (usually "www").

 </p>

 </li>

 <li>

@@ -861,11 +974,10 @@ url - The entire URL used for the request.
 </p>

 </li>

 </ul></div>

-<h4 id="_path_parameters_query_parameters_and_request_parameters">8.1.1. path_parameters, query_parameters and request_parameters</h4>

-<div class="para"><p>TODO: Does this belong here?</p></div>

-<div class="para"><p>Rails collects all of the parameters sent along with the request in the <tt>params</tt> hash, whether they are sent as part of the query string or the post body. The request object has three accessors that give you access to these parameters depending on where they came from. The <tt>query_parameters</tt> hash contains parameters that were sent as part of the query string while the <tt>request_parameters</tt> hash contains parameters sent as part of the post body. The <tt>path_parameters</tt> hash contains parameters that were recognised by the routing as being part of the path leading to this particular controller and action.</p></div>

-<h3 id="_the_response">8.2. The response</h3>

-<div class="para"><p>The response objects is not usually used directly, but is built up during the execution of the action and rendering of the data that is being sent back to the user, but sometimes - like in an after filter - it can be useful to access the response directly. Some of these accessor methods also have setters, allowing you to change their values.</p></div>

+<h4 id="_tt_path_parameters_tt_tt_query_parameters_tt_and_tt_request_parameters_tt">9.1.1. <tt>path_parameters</tt>, <tt>query_parameters</tt> and <tt>request_parameters</tt></h4>

+<div class="para"><p>Rails collects all of the parameters sent along with the request in the <tt>params</tt> hash, whether they are sent as part of the query string or the post body. The request object has three accessors that give you access to these parameters depending on where they came from. The <tt>query_parameters</tt> hash contains parameters that were sent as part of the query string while the <tt>request_parameters</tt> hash contains parameters sent as part of the post body. The <tt>path_parameters</tt> hash contains parameters that were recognized by the routing as being part of the path leading to this particular controller and action.</p></div>

+<h3 id="_the_tt_response_tt_object">9.2. The <tt>response</tt> Object</h3>

+<div class="para"><p>The response object is not usually used directly, but is built up during the execution of the action and rendering of the data that is being sent back to the user, but sometimes - like in an after filter - it can be useful to access the response directly. Some of these accessor methods also have setters, allowing you to change their values.</p></div>

 <div class="ilist"><ul>

 <li>

 <p>

@@ -892,11 +1004,25 @@ content_type - The content type of the response.
 charset - The character set being used for the response. Default is "utf8".

 </p>

 </li>

+<li>

+<p>

+headers - Headers used for the response.

+</p>

+</li>

 </ul></div>

+<h4 id="_setting_custom_headers">9.2.1. Setting Custom Headers</h4>

+<div class="para"><p>If you want to set custom headers for a response then <tt>response.headers</tt> is the place to do it. The headers attribute is a hash which maps header names to their values, and Rails will set some of them - like "Content-Type" - automatically. If you want to add or change a header, just assign it to <tt>headers</tt> with the name and value:</p></div>

+<div class="listingblock">

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt>response<span style="color: #990000">.</span>headers<span style="color: #990000">[</span><span style="color: #FF0000">"Content-Type"</span><span style="color: #990000">]</span> <span style="color: #990000">=</span> <span style="color: #FF0000">"application/pdf"</span>

+</tt></pre></div></div>

 </div>

-<h2 id="_http_basic_authentication">9. HTTP Basic Authentication</h2>

+<h2 id="_http_basic_authentication">10. HTTP Basic Authentication</h2>

 <div class="sectionbody">

-<div class="para"><p>Rails comes with built-in HTTP Basic authentication. This is an authentication scheme that is supported by the majority of browsers and other HTTP clients. As an example, we will create an administration section which will only be available by entering a username and a password into the browser's HTTP Basic dialog window. Using the built-in authentication is quite easy and only requires you to use one method, <a href="http://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic/ControllerMethods.html#M000610">authenticate_or_request_with_http_basic</a>.</p></div>

+<div class="para"><p>Rails comes with built-in HTTP Basic authentication. This is an authentication scheme that is supported by the majority of browsers and other HTTP clients. As an example, consider an administration section which will only be available by entering a username and a password into the browser's HTTP Basic dialog window. Using the built-in authentication is quite easy and only requires you to use one method, <tt>authenticate_or_request_with_http_basic</tt>.</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -920,9 +1046,9 @@ private
 </tt></pre></div></div>

 <div class="para"><p>With this in place, you can create namespaced controllers that inherit from AdminController. The before filter will thus be run for all actions in those controllers, protecting them with HTTP Basic authentication.</p></div>

 </div>

-<h2 id="_streaming_and_file_downloads">10. Streaming and file downloads</h2>

+<h2 id="_streaming_and_file_downloads">11. Streaming and File Downloads</h2>

 <div class="sectionbody">

-<div class="para"><p>Sometimes you may want to send a file to the user instead of rendering an HTML page. All controllers in Rails have the <a href="http://api.rubyonrails.org/classes/ActionController/Streaming.html#M000624">send_data</a> and the <a href="http://api.rubyonrails.org/classes/ActionController/Streaming.html#M000623">send_file</a> methods, that will both stream data to the client. <tt>send_file</tt> is a convenience method which lets you provide the name of a file on the disk and it will stream the contents of that file for you.</p></div>

+<div class="para"><p>Sometimes you may want to send a file to the user instead of rendering an HTML page. All controllers in Rails have the <tt>send_data</tt> and the <tt>send_file</tt> methods, that will both stream data to the client. <tt>send_file</tt> is a convenience method which lets you provide the name of a file on the disk and it will stream the contents of that file for you.</p></div>

 <div class="para"><p>To stream data to the client, use <tt>send_data</tt>:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -952,7 +1078,7 @@ private
 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

 <div class="para"><p>The <tt>download_pdf</tt> action in the example above will call a private method which actually generates the file (a PDF document) and returns it as a string. This string will then be streamed to the client as a file download and a filename will be suggested to the user. Sometimes when streaming files to the user, you may not want them to download the file. Take images, for example, which can be embedded into HTML pages. To tell the browser a file is not meant to be downloaded, you can set the <tt>:disposition</tt> option to "inline". The opposite and default value for this option is "attachment".</p></div>

-<h3 id="_sending_files">10.1. Sending files</h3>

+<h3 id="_sending_files">11.1. Sending Files</h3>

 <div class="para"><p>If you want to send a file that already exists on disk, use the <tt>send_file</tt> method. This is usually not recommended, but can be useful if you want to perform some authentication before letting the user download the file.</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -975,7 +1101,7 @@ http://www.gnu.org/software/src-highlite -->
 <td class="icon">

 <img src="./images/icons/warning.png" alt="Warning" />

 </td>

-<td class="content">Be careful when using (or just don't use) "outside" data (params, cookies, etc) to locate the file on disk, as this is a security risk as someone could gain access to files they are not meant to have access to.</td>

+<td class="content">Be careful when using (or just don't use) "outside" data (params, cookies, etc) to locate the file on disk, as this is a security risk that might allow someone to gain access to files they are not meant to see.</td>

 </tr></table>

 </div>

 <div class="admonitionblock">

@@ -986,8 +1112,8 @@ http://www.gnu.org/software/src-highlite -->
 <td class="content">It is not recommended that you stream static files through Rails if you can instead keep them in a public folder on your web server. It is much more efficient to let the user download the file directly using Apache or another web server, keeping the request from unnecessarily going through the whole Rails stack.</td>

 </tr></table>

 </div>

-<h3 id="_restful_downloads">10.2. RESTful downloads</h3>

-<div class="para"><p>While <tt>send_data</tt> works just fine, if you are creating a RESTful application having separate actions for file downloads is usually not necessary. In REST terminology, the PDF file from the example above can be considered just another representation of the client resource. Rails provides an easy and quite sleek way of doing "RESTful downloads". Let's try to rewrite the example so that the PDF download is a part of the <tt>show</tt> action:</p></div>

+<h3 id="_restful_downloads">11.2. RESTful Downloads</h3>

+<div class="para"><p>While <tt>send_data</tt> works just fine, if you are creating a RESTful application having separate actions for file downloads is usually not necessary. In REST terminology, the PDF file from the example above can be considered just another representation of the client resource. Rails provides an easy and quite sleek way of doing "RESTful downloads". Here's how you can rewrite the example so that the PDF download is a part of the <tt>show</tt> action, without any streaming:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -1007,7 +1133,7 @@ http://www.gnu.org/software/src-highlite -->
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>In order for this example to work, we have to add the PDF MIME type to Rails. This can be done by adding the following line to the file <tt>config/initializers/mime_types.rb</tt>:</p></div>

+<div class="para"><p>In order for this example to work, you have to add the PDF MIME type to Rails. This can be done by adding the following line to the file <tt>config/initializers/mime_types.rb</tt>:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -1029,9 +1155,9 @@ http://www.gnu.org/software/src-highlite -->
 <pre><tt>GET /clients/1.pdf</tt></pre>

 </div></div>

 </div>

-<h2 id="_parameter_filtering">11. Parameter filtering</h2>

+<h2 id="_parameter_filtering">12. Parameter Filtering</h2>

 <div class="sectionbody">

-<div class="para"><p>Rails keeps a log file for each environment (development, test and production) in the "log" folder. These are extremely useful when debugging what's actually going on in your application, but in a live application you may not want every bit of information to be stored in the log file. The <a href="http://api.rubyonrails.org/classes/ActionController/Base.html#M000837">filter_parameter_logging</a> method can be used to filter out sensitive information from the log. It works by replacing certain keys in the <tt>params</tt> hash with "[FILTERED]" as they are written to the log. As an example, let's see how to filter all parameters with keys that include "password":</p></div>

+<div class="para"><p>Rails keeps a log file for each environment (development, test and production) in the "log" folder. These are extremely useful when debugging what's actually going on in your application, but in a live application you may not want every bit of information to be stored in the log file. The <tt>filter_parameter_logging</tt> method can be used to filter out sensitive information from the log. It works by replacing certain values in the <tt>params</tt> hash with "[FILTERED]" as they are written to the log. As an example, let's see how to filter all parameters with keys that include "password":</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -1045,14 +1171,14 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>The method works recursively through all levels of the params hash and takes an optional second parameter which is used as the replacement string if present. It can also take a block which receives each key in return and replaces those for which the block returns true.</p></div>

 </div>

-<h2 id="_rescue">12. Rescue</h2>

+<h2 id="_rescue">13. Rescue</h2>

 <div class="sectionbody">

 <div class="para"><p>Most likely your application is going to contain bugs or otherwise throw an exception that needs to be handled. For example, if the user follows a link to a resource that no longer exists in the database, Active Record will throw the ActiveRecord::RecordNotFound exception. Rails' default exception handling displays a 500 Server Error message for all exceptions. If the request was made locally, a nice traceback and some added information gets displayed so you can figure out what went wrong and deal with it. If the request was remote Rails will just display a simple "500 Server Error" message to the user, or a "404 Not Found" if there was a routing error or a record could not be found. Sometimes you might want to customize how these errors are caught and how they're displayed to the user. There are several levels of exception handling available in a Rails application:</p></div>

-<h3 id="_the_default_500_and_404_templates">12.1. The default 500 and 404 templates</h3>

+<h3 id="_the_default_500_and_404_templates">13.1. The Default 500 and 404 Templates</h3>

 <div class="para"><p>By default a production application will render either a 404 or a 500 error message. These messages are contained in static HTML files in the <tt>public</tt> folder, in <tt>404.html</tt> and <tt>500.html</tt> respectively. You can customize these files to add some extra information and layout, but remember that they are static; i.e. you can't use RHTML or layouts in them, just plain HTML.</p></div>

-<h3 id="_tt_rescue_from_tt">12.2. <tt>rescue_from</tt></h3>

-<div class="para"><p>If you want to do something a bit more elaborate when catching errors, you can use <a href=":http://api.rubyonrails.org/classes/ActionController/Rescue/ClassMethods.html#M000620">rescue_from</a>, which handles exceptions of a certain type (or multiple types) in an entire controller and its subclasses. When an exception occurs which is caught by a rescue_from directive, the exception object is passed to the handler. The handler can be a method or a Proc object passed to the <tt>:with</tt> option. You can also use a block directly instead of an explicit Proc object.</p></div>

-<div class="para"><p>Let's see how we can use rescue_from to intercept all ActiveRecord::RecordNotFound errors and do something with them.</p></div>

+<h3 id="_tt_rescue_from_tt">13.2. <tt>rescue_from</tt></h3>

+<div class="para"><p>If you want to do something a bit more elaborate when catching errors, you can use <tt>rescue_from</tt>, which handles exceptions of a certain type (or multiple types) in an entire controller and its subclasses. When an exception occurs which is caught by a <tt>rescue_from</tt> directive, the exception object is passed to the handler. The handler can be a method or a Proc object passed to the <tt>:with</tt> option. You can also use a block directly instead of an explicit Proc object.</p></div>

+<div class="para"><p>Here's how you can use <tt>rescue_from</tt> to intercept all ActiveRecord::RecordNotFound errors and do something with them.</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -1070,7 +1196,7 @@ private
 

 <span style="font-weight: bold"><span style="color: #0000FF">end</span></span>

 </tt></pre></div></div>

-<div class="para"><p>Of course, this example is anything but elaborate and doesn't improve the default exception handling at all, but once you can catch all those exceptions you're free to do whatever you want with them. For example, you could create custom exception classes that will be thrown when a user doesn't have access to a certain section of your application:</p></div>

+<div class="para"><p>Of course, this example is anything but elaborate and doesn't improve on the default exception handling at all, but once you can catch all those exceptions you're free to do whatever you want with them. For example, you could create custom exception classes that will be thrown when a user doesn't have access to a certain section of your application:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -1117,6 +1243,17 @@ private
 </tr></table>

 </div>

 </div>

+<h2 id="_changelog">14. Changelog</h2>

+<div class="sectionbody">

+<div class="para"><p><a href="http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/17">Lighthouse ticket</a></p></div>

+<div class="ilist"><ul>

+<li>

+<p>

+November 4, 2008: First release version by Tore Darrell

+</p>

+</li>

+</ul></div>

+</div>

 
 		</div>
 	</div>
diff --git a/railties/doc/guides/html/activerecord_validations_callbacks.html b/railties/doc/guides/html/activerecord_validations_callbacks.html
new file mode 100644
index 0000000000..c9128a8533
--- /dev/null
+++ b/railties/doc/guides/html/activerecord_validations_callbacks.html
@@ -0,0 +1,267 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" lang="en" xml:lang="en">
+<head>
+	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+	<title>Active Record Validations and Callbacks</title>
+	<!--[if lt IE 8]>
+	<script src="http://ie7-js.googlecode.com/svn/version/2.0(beta3)/IE8.js" type="text/javascript"></script>
+	<![endif]-->
+	<link href="stylesheets/base.css" media="screen" rel="Stylesheet" type="text/css" />
+	<link href="stylesheets/forms.css" media="screen" rel="Stylesheet" type="text/css" />
+	<link href="stylesheets/more.css" media="screen" rel="Stylesheet" type="text/css" />
+	<style type="text/css">
+		div#container {
+	max-width: 900px;
+	padding-bottom: 3em;
+}
+
+div#content {
+	margin-left: 200px;
+}
+
+div#container.notoc {
+	max-width: 600px;
+}
+
+.notoc div#content {
+	margin-left: 0;
+}
+
+pre {
+	line-height: 1.4em;
+}
+
+#content p tt {
+	background: #eeeeee;
+	border: solid 1px #cccccc;
+	padding: 3px;
+}
+
+dt {
+	font-weight: bold;
+}
+
+#content dt tt {
+	font-size: 10pt;
+}
+
+dd {
+	margin-left: 3em;
+}
+
+#content dt tt, #content pre tt {
+	background: none;
+	padding: 0;
+	border: 0;
+}
+
+#content .olist ol {
+	margin-left: 2em;
+}
+
+#header {
+	position: relative;
+	max-width: 840px;
+	margin-left: auto;
+	margin-right: auto;
+}
+
+#header.notoc {
+	max-width: 580px;
+}
+
+#logo {
+	position: absolute;
+	left: 10px;
+	top: 10px;
+	width: 110px;
+	height: 140px;
+}
+
+div#header h1#site_title {
+	background: url('images/ruby_on_rails_by_mike_rundle2.gif') top left no-repeat;
+	position: absolute;
+	width: 392px;
+	height: 55px;
+	left: 145px;
+	top: 20px;
+	margin: 0;
+	padding: 0;
+}
+
+#site_title span {
+	display: none;
+}
+
+#site_title_tagline {
+	display: none;
+}
+
+ul#navMain {
+	position: absolute;
+	margin: 0;
+	padding: 0;
+	top: 97px;
+	left: 145px;
+}
+
+.left-floaty, .right-floaty {
+	padding: 15px;
+}
+
+.admonitionblock,
+.tableblock {
+	margin-left: 1em;
+	margin-right: 1em;
+	margin-top: 0.25em;
+	margin-bottom: 1em;
+}
+
+.admonitionblock .icon {
+	padding-right: 8px;
+}
+
+.admonitionblock .content {
+	border: solid 1px #ffda78;
+	background: #fffebd;
+	padding: 10px;
+	padding-top: 8px;
+	padding-bottom: 8px;
+}
+
+.admonitionblock .title {
+	font-size: 140%;
+	margin-bottom: 0.5em;
+}
+
+.tableblock table {
+	border: solid 1px #aaaaff;
+	background: #f0f0ff;
+}
+
+.tableblock th {
+	background: #e0e0e0;
+}
+
+.tableblock th,
+.tableblock td {
+	padding: 3px;
+	padding-left: 5px;
+	padding-right: 5px;
+}
+
+.sidebarblock {
+	margin-top: 0.25em;
+	margin: 1em;
+	border: solid 1px #ccccbb;
+	padding: 8px;
+	background: #ffffe0;
+}
+
+.sidebarblock .sidebar-title {
+	font-size: 140%;
+	font-weight: 600;
+	margin-bottom: 0.3em;
+}
+
+.sidebarblock .sidebar-content > .para:last-child > p {
+	margin-bottom: 0;
+}
+
+.sidebarblock .sidebar-title a {
+	text-decoration: none;
+}
+
+.sidebarblock .sidebar-title a:hover {
+	text-decoration: underline;
+}
+
+	</style>
+</head>
+<body>
+	<div id="header" >
+		<div id="logo">
+			<a href="index.html" title="Ruby on Rails"><img src="images/rails_logo_remix.gif" alt="Rails" height="140" width="110" /></a>
+		</div>
+		
+		<h1 id="site_title"><span>Ruby on Rails</span></h1>
+		<h2 id="site_title_tagline">Sustainable productivity for web-application development</h2>
+
+		<ul id="navMain">
+			<li class="first-child"><a href="http://www.rubyonrails.org/" title="Ruby on Rails" class="ruby_on_rails">Ruby on Rails</a></li>
+			<li><a class="manuals" href="index.html" title="Manuals Index">Guides Index</a></li>
+		</ul>
+	</div>
+
+	<div id="container">
+		
+		<div id="sidebar">
+			<h2>Chapters</h2>
+			<ol>
+					<li>
+					<a href="#_active_record_validations">Active Record Validations</a>
+					</li>
+					<li>
+					<a href="#_credits">Credits</a>
+					</li>
+					<li>
+					<a href="#_changelog">Changelog</a>
+					</li>
+			</ol>
+		</div>
+		
+		<div id="content">
+				<h1>Active Record Validations and Callbacks</h1>
+			<div id="preamble">

+<div class="sectionbody">

+<div class="para"><p>This guide teaches you how to work with the lifecycle of your Active Record objects. More precisely, you will learn how to validate the state of your objects before they go into the database and also how to teach them to perform custom operations at certain points of their lifecycles.</p></div>

+<div class="para"><p>After reading this guide and trying out the presented concepts, we hope that you'll be able to:</p></div>

+<div class="ilist"><ul>

+<li>

+<p>

+Correctly use all the built-in Active Record validation helpers

+</p>

+</li>

+<li>

+<p>

+Create your own custom validation methods

+</p>

+</li>

+<li>

+<p>

+Work with the error messages generated by the validation proccess

+</p>

+</li>

+<li>

+<p>

+Register callback methods that will execute custom operations during your objects lifecycle, for example before/after they are saved.

+</p>

+</li>

+<li>

+<p>

+Create special classes that encapsulate common behaviour for your callbacks

+</p>

+</li>

+<li>

+<p>

+Create Observers - classes with callback methods specific for each of your models, keeping the callback code outside your models' declarations.

+</p>

+</li>

+</ul></div>

+</div>

+</div>

+<h2 id="_active_record_validations">1. Active Record Validations</h2>

+<div class="sectionbody">

+</div>

+<h2 id="_credits">2. Credits</h2>

+<div class="sectionbody">

+</div>

+<h2 id="_changelog">3. Changelog</h2>

+<div class="sectionbody">

+<div class="para"><p><a href="http://rails.lighthouseapp.com/projects/16213/tickets/26-active-record-validations-and-callbacks">http://rails.lighthouseapp.com/projects/16213/tickets/26-active-record-validations-and-callbacks</a></p></div>

+</div>

+
+		</div>
+	</div>
+</body>
+</html>
diff --git a/railties/doc/guides/html/authors.html b/railties/doc/guides/html/authors.html
index 973cf7cd2e..a54135b14d 100644
--- a/railties/doc/guides/html/authors.html
+++ b/railties/doc/guides/html/authors.html
@@ -218,6 +218,19 @@ work with Rails. His near-daily links and other blogging can be found at <a href
 Cofounder of <a href="http://www.eventioz.com">Eventioz</a>. He has been using Rails since 2006 and contributing since early 2008.

 Can be found at gmail, twitter, freenode, everywhere as miloops.</p></div>

 </div></div>

+<div class="sidebarblock" id="hawe">

+<div class="sidebar-content">

+<div class="sidebar-title">Heiko Webers</div>

+<div class="para"><p>Heiko Webers is the founder of <a href="http://www.bauland42.de">bauland42</a>, a German web application security consulting and development

+company focused on Ruby on Rails. He blogs at <a href="http://www.rorsecurity.info">http://www.rorsecurity.info</a>. After 10 years of desktop application development,

+Heiko has rarely looked back.</p></div>

+</div></div>

+<div class="sidebarblock" id="toretore">

+<div class="sidebar-content">

+<div class="sidebar-title">Tore Darell</div>

+<div class="para"><p>Tore Darell is an independent developer based in Menton, France who specialises in cruft-free web applications using Ruby, Rails

+and unobtrusive JavaScript. His home on the internet is his blog <a href="http://tore.darell.no/">Sneaky Abstractions</a>.</p></div>

+</div></div>

 </div>

 </div>

 
diff --git a/railties/doc/guides/html/debugging_rails_applications.html b/railties/doc/guides/html/debugging_rails_applications.html
index bf1e442d59..95f5b39e4c 100644
--- a/railties/doc/guides/html/debugging_rails_applications.html
+++ b/railties/doc/guides/html/debugging_rails_applications.html
@@ -208,6 +208,8 @@ ul#navMain {
 						
 							<li><a href="#_inspect">inspect</a></li>
 						
+							<li><a href="#_debugging_javascript">Debugging Javascript</a></li>
+						
 						</ul>
 					</li>
 					<li>
@@ -253,6 +255,19 @@ ul#navMain {
 						</ul>
 					</li>
 					<li>
+					<a href="#_debugging_memory_leaks">Debugging Memory Leaks</a>
+						<ul>
+						
+							<li><a href="#_bleakhouse">BleakHouse</a></li>
+						
+							<li><a href="#_valgrind">Valgrind</a></li>
+						
+						</ul>
+					</li>
+					<li>
+					<a href="#_plugins_for_debugging">Plugins for Debugging</a>
+					</li>
+					<li>
 					<a href="#_references">References</a>
 					</li>
 					<li>
@@ -325,10 +340,7 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>You'll see something like this:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>--- !ruby/object:Post

 attributes:

   updated_at: 2008-09-05 22:55:47

@@ -340,8 +352,8 @@ attributes:
 attributes_cache: {}

 

 

-Title: Rails debugging guide

-</tt></pre></div></div>

+Title: Rails debugging guide</tt></pre>

+</div></div>

 <h3 id="_to_yaml">1.2. to_yaml</h3>

 <div class="para"><p>Displaying an instance variable, or any other object or method, in yaml format can be achieved this way:</p></div>

 <div class="listingblock">

@@ -358,10 +370,7 @@ http://www.gnu.org/software/src-highlite -->
 <div class="para"><p>The <tt>to_yaml</tt> method converts the method to YAML format leaving it more readable, and then the <tt>simple_format</tt> helper is used to render each line as in the console. This is how <tt>debug</tt> method does its magic.</p></div>

 <div class="para"><p>As a result of this, you will have something like this in your view:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>--- !ruby/object:Post

 attributes:

 updated_at: 2008-09-05 22:55:47

@@ -372,8 +381,8 @@ id: "1"
 created_at: 2008-09-05 22:55:47

 attributes_cache: {}

 

-Title: Rails debugging guide

-</tt></pre></div></div>

+Title: Rails debugging guide</tt></pre>

+</div></div>

 <h3 id="_inspect">1.3. inspect</h3>

 <div class="para"><p>Another useful method for displaying object values is <tt>inspect</tt>, especially when working with arrays or hashes. This will print the object value as a string. For example:</p></div>

 <div class="listingblock">

@@ -389,14 +398,37 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>Will be rendered as follows:</p></div>

 <div class="listingblock">

+<div class="content">

+<pre><tt>[1, 2, 3, 4, 5]

+

+Title: Rails debugging guide</tt></pre>

+</div></div>

+<h3 id="_debugging_javascript">1.4. Debugging Javascript</h3>

+<div class="para"><p>Rails has built-in support to debug RJS, to active it, set <tt>ActionView::Base.debug_rjs</tt> to <em>true</em>, this will specify whether RJS responses should be wrapped in a try/catch block that alert()s the caught exception (and then re-raises it).</p></div>

+<div class="para"><p>To enable it, add the following in the <tt>Rails::Initializer do |config|</tt> block inside <tt>environment.rb</tt>:</p></div>

+<div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

 http://www.lorenzobettini.it

 http://www.gnu.org/software/src-highlite -->

-<pre><tt>[1, 2, 3, 4, 5]

-

-Title: Rails debugging guide

+<pre><tt>config<span style="color: #990000">.</span>action_view<span style="color: #990000">[:</span>debug_rjs<span style="color: #990000">]</span> <span style="color: #990000">=</span> <span style="font-weight: bold"><span style="color: #0000FF">true</span></span>

+</tt></pre></div></div>

+<div class="para"><p>Or, at any time, setting <tt>ActionView::Base.debug_rjs</tt> to <em>true</em>:</p></div>

+<div class="listingblock">

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt>ActionView<span style="color: #990000">::</span>Base<span style="color: #990000">.</span>debug_rjs <span style="color: #990000">=</span> <span style="font-weight: bold"><span style="color: #0000FF">true</span></span>

 </tt></pre></div></div>

+<div class="admonitionblock">

+<table><tr>

+<td class="icon">

+<img src="./images/icons/tip.png" alt="Tip" />

+</td>

+<td class="content">For more information on debugging javascript refer to <a href="http://getfirebug.com/">Firebug</a>, the popular debugger for Firefox.</td>

+</tr></table>

+</div>

 </div>

 <h2 id="_the_logger">2. The Logger</h2>

 <div class="sectionbody">

@@ -488,11 +520,8 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>Here's an example of the log generated by this method:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

-<pre><tt>Processing PostsController#create (for <span style="color: #009900">127.0.0.1</span> at 2008-09-08 11:52:54) [POST]

+<div class="content">

+<pre><tt>Processing PostsController#create (for 127.0.0.1 at 2008-09-08 11:52:54) [POST]

   Session ID: BAh7BzoMY3NyZl9pZCIlMDY5MWU1M2I1ZDRjODBlMzkyMWI1OTg2NWQyNzViZjYiCmZsYXNoSUM6J0FjdGl

 vbkNvbnRyb2xsZXI6OkZsYXNoOjpGbGFzaEhhc2h7AAY6CkB1c2VkewA=--b18cd92fba90eacf8137e5f6b3b06c4d724596a4

   Parameters: {"commit"=&gt;"Create", "post"=&gt;{"title"=&gt;"Debugging Rails",

@@ -506,8 +535,8 @@ Post should be valid: true
  'I''m learning how to print in logs!!!', 'f', '2008-09-08 14:52:54')

 The post was saved and now is the user is going to be redirected...

 Redirected to #&lt;Post:0x20af760&gt;

-Completed in 0.01224 (81 reqs/sec) | DB: 0.00044 (3%) | 302 Found [http://localhost/posts]

-</tt></pre></div></div>

+Completed in 0.01224 (81 reqs/sec) | DB: 0.00044 (3%) | 302 Found [http://localhost/posts]</tt></pre>

+</div></div>

 <div class="para"><p>Adding extra logging like this makes it easy to search for unexpected or unusual behavior in your logs. If you add extra logging, be sure to make sensible use of log levels, to avoid filling your production logs with useless trivia.</p></div>

 </div>

 <h2 id="_debugging_with_ruby_debug">3. Debugging with ruby-debug</h2>

@@ -540,12 +569,9 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>If you see the message in the console or logs:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

-<pre><tt>***** Debugger requested, but was not available: Start server with --debugger to enable *****

-</tt></pre></div></div>

+<div class="content">

+<pre><tt>***** Debugger requested, but was not available: Start server with --debugger to enable *****</tt></pre>

+</div></div>

 <div class="para"><p>Make sure you have started your web server with the option <tt>&#8212;debugger</tt>:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -576,7 +602,7 @@ http://www.gnu.org/software/src-highlite -->
 <pre><tt>@posts = Post.find(:all)

 (rdb:7)</tt></pre>

 </div></div>

-<div class="para"><p>Now it's time to play and dig into your application. A good place to start is by asking the debugger for help&#8230; so type: <tt>help</tt> (You didn't see that coming, right?)</p></div>

+<div class="para"><p>Now it's time to explore and dig into your application. A good place to start is by asking the debugger for help&#8230; so type: <tt>help</tt> (You didn't see that coming, right?)</p></div>

 <div class="listingblock">

 <div class="content">

 <pre><tt>(rdb:7) help

@@ -969,16 +995,104 @@ No breakpoints.</tt></pre>
 </div>

 <div class="para"><p>Here's a good start for an <tt>.rdebugrc</tt>:</p></div>

 <div class="listingblock">

+<div class="content">

+<pre><tt>set autolist

+set forcestep

+set listsize 25</tt></pre>

+</div></div>

+</div>

+<h2 id="_debugging_memory_leaks">4. Debugging Memory Leaks</h2>

+<div class="sectionbody">

+<div class="para"><p>A Ruby application (on Rails or not), can leak memory - either in the Ruby code or at the C code level.</p></div>

+<div class="para"><p>In this section, you will learn how to find and fix such leaks by using Bleak House and Valgrind debugging tools.</p></div>

+<h3 id="_bleakhouse">4.1. BleakHouse</h3>

+<div class="para"><p><a href="http://github.com/fauna/bleak_house/tree/master">BleakHouse</a> is a library for finding memory leaks.</p></div>

+<div class="para"><p>If a Ruby object does not go out of scope, the Ruby Garbage Collector won't sweep it since it is referenced somewhere. Leaks like this can grow slowly and your application will consume more and more memory, gradually affecting the overall system performance. This tool will help you find leaks on the Ruby heap.</p></div>

+<div class="para"><p>To install it run:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>sudo gem install bleak_house</tt></pre>

+</div></div>

+<div class="para"><p>Then setup you application for profiling. Then add the following at the bottom of config/environment.rb:</p></div>

+<div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

 http://www.lorenzobettini.it

 http://www.gnu.org/software/src-highlite -->

-<pre><tt>set autolist

-set forcestep

-set listsize 25

+<pre><tt><span style="font-weight: bold"><span style="color: #000080">require</span></span> <span style="color: #FF0000">'bleak_house'</span> <span style="font-weight: bold"><span style="color: #0000FF">if</span></span> ENV<span style="color: #990000">[</span><span style="color: #FF0000">'BLEAK_HOUSE'</span><span style="color: #990000">]</span>

 </tt></pre></div></div>

+<div class="para"><p>Start a server instance with BleakHouse integration:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>RAILS_ENV=production BLEAK_HOUSE=1 ruby-bleak-house ./script/server</tt></pre>

+</div></div>

+<div class="para"><p>Make sure to run a couple hundred requests to get better data samples, then press <tt>CTRL-C</tt>. The server will stop and Bleak House will produce a dumpfile in <tt>/tmp</tt>:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>** BleakHouse: working...

+** BleakHouse: complete

+** Bleakhouse: run 'bleak /tmp/bleak.5979.0.dump' to analyze.</tt></pre>

+</div></div>

+<div class="para"><p>To analyze it, just run the listed command. The top 20 leakiest lines will be listed:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>  191691 total objects

+  Final heap size 191691 filled, 220961 free

+  Displaying top 20 most common line/class pairs

+  89513 __null__:__null__:__node__

+  41438 __null__:__null__:String

+  2348 /opt/local//lib/ruby/site_ruby/1.8/rubygems/specification.rb:557:Array

+  1508 /opt/local//lib/ruby/gems/1.8/specifications/gettext-1.90.0.gemspec:14:String

+  1021 /opt/local//lib/ruby/gems/1.8/specifications/heel-0.2.0.gemspec:14:String

+   951 /opt/local//lib/ruby/site_ruby/1.8/rubygems/version.rb:111:String

+   935 /opt/local//lib/ruby/site_ruby/1.8/rubygems/specification.rb:557:String

+   834 /opt/local//lib/ruby/site_ruby/1.8/rubygems/version.rb:146:Array

+  ...</tt></pre>

+</div></div>

+<div class="para"><p>This way you can find where your application is leaking memory and fix it.</p></div>

+<div class="para"><p>If <a href="http://github.com/fauna/bleak_house/tree/master">BleakHouse</a> doesn't report any heap growth but you still have memory growth, you might have a broken C extension, or real leak in the interpreter. In that case, try using Valgrind to investigate further.</p></div>

+<h3 id="_valgrind">4.2. Valgrind</h3>

+<div class="para"><p><a href="http://valgrind.org/">Valgrind</a> is a Linux-only application for detecting C-based memory leaks and race conditions.</p></div>

+<div class="para"><p>There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. For example, a C extension in the interpreter calls <tt>malloc()</tt> but is doesn't properly call <tt>free()</tt>, this memory won't be available until the app terminates.</p></div>

+<div class="para"><p>For further information on how to install Valgrind and use with Ruby, refer to <a href="http://blog.evanweaver.com/articles/2008/02/05/valgrind-and-ruby/">Valgrind and Ruby</a> by Evan Weaver.</p></div>

 </div>

-<h2 id="_references">4. References</h2>

+<h2 id="_plugins_for_debugging">5. Plugins for Debugging</h2>

+<div class="sectionbody">

+<div class="para"><p>There are some Rails plugins to help you to find errors and debug your application. Here is a list of useful plugins for debugging:</p></div>

+<div class="ilist"><ul>

+<li>

+<p>

+<a href="http://github.com/drnic/rails-footnotes/tree/master">Footnotes</a>: Every Rails page has footnotes that link give request information and link back to your source via TextMate.

+</p>

+</li>

+<li>

+<p>

+<a href="http://github.com/ntalbott/query_trace/tree/master">Query Trace</a>: Adds query origin tracing to your logs.

+</p>

+</li>

+<li>

+<p>

+<a href="http://github.com/dan-manges/query_stats/tree/master">Query Stats</a>: A Rails plugin to track database queries.

+</p>

+</li>

+<li>

+<p>

+<a href="http://code.google.com/p/query-reviewer/">Query Reviewer</a>: This rails plugin not only runs "EXPLAIN" before each of your select queries in development, but provides a small DIV in the rendered output of each page with the summary of warnings for each query that it analyzed.

+</p>

+</li>

+<li>

+<p>

+<a href="http://github.com/rails/exception_notification/tree/master">Exception Notifier</a>: Provides a mailer object and a default set of templates for sending email notifications when errors occur in a Rails application.

+</p>

+</li>

+<li>

+<p>

+<a href="http://github.com/defunkt/exception_logger/tree/master">Exception Logger</a>: Logs your Rails exceptions in the database and provides a funky web interface to manage them.

+</p>

+</li>

+</ul></div>

+</div>

+<h2 id="_references">6. References</h2>

 <div class="sectionbody">

 <div class="ilist"><ul>

 <li>

@@ -1026,14 +1140,24 @@ set listsize 25
 <a href="http://wiki.rubyonrails.org/rails/pages/HowtoConfigureLogging">Ruby on Rails Wiki: How to Configure Logging</a>

 </p>

 </li>

+<li>

+<p>

+<a href="http://blog.evanweaver.com/files/doc/fauna/bleak_house/files/README.html">Bleak House Documentation</a>

+</p>

+</li>

 </ul></div>

 </div>

-<h2 id="_changelog">5. Changelog</h2>

+<h2 id="_changelog">7. Changelog</h2>

 <div class="sectionbody">

 <div class="para"><p><a href="http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/5">Lighthouse ticket</a></p></div>

 <div class="ilist"><ul>

 <li>

 <p>

+November 3, 2008: Accepted for publication. Added RJS, memory leaks and plugins chapters by <a href="../authors.html#miloops">Emilio Tagua</a>

+</p>

+</li>

+<li>

+<p>

 October 19, 2008: Copy editing pass by <a href="../authors.html#mgunderloy">Mike Gunderloy</a>

 </p>

 </li>

diff --git a/railties/doc/guides/html/finders.html b/railties/doc/guides/html/finders.html
index f8396bb517..18bc32306f 100644
--- a/railties/doc/guides/html/finders.html
+++ b/railties/doc/guides/html/finders.html
@@ -373,27 +373,21 @@ http://www.gnu.org/software/src-highlite -->
 <pre><tt><span style="font-weight: bold"><span style="color: #0000FF">SELECT</span></span> <span style="color: #990000">*</span> <span style="font-weight: bold"><span style="color: #0000FF">FROM</span></span> <span style="color: #990000">+</span>clients<span style="color: #990000">+</span> <span style="font-weight: bold"><span style="color: #0000FF">WHERE</span></span> <span style="color: #990000">(+</span>clients<span style="color: #990000">+.+</span>id<span style="color: #990000">+</span> <span style="font-weight: bold"><span style="color: #0000FF">IN</span></span> <span style="color: #990000">(</span><span style="color: #993399">1</span><span style="color: #990000">,</span><span style="color: #993399">2</span><span style="color: #990000">))</span>

 </tt></pre></div></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>&gt;&gt; Client.find(1,2)

 =&gt; [#&lt;Client id: 1, name: =&gt; "Ryan", locked: false, orders_count: 2,

   created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50"&gt;,

   #&lt;Client id: 2, name: =&gt; "Michael", locked: false, orders_count: 3,

-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;]

-</tt></pre></div></div>

+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;]</tt></pre>

+</div></div>

 <div class="para"><p>Note that if you pass in a list of numbers that the result will be returned as an array, not as a single <tt>Client</tt> object.</p></div>

 <div class="para"><p>If you wanted to find the first client you would simply type <tt>Client.first</tt> and that would find the first client created in your clients table:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>&gt;&gt; Client.first

 =&gt; #&lt;Client id: 1, name: =&gt; "Ryan", locked: false, orders_count: 2,

-  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50"&gt;

-</tt></pre></div></div>

+  created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50"&gt;</tt></pre>

+</div></div>

 <div class="para"><p>If you were running script/server you might see the following output:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -405,14 +399,11 @@ http://www.gnu.org/software/src-highlite -->
 <div class="para"><p>Indicating the query that Rails has performed on your database.</p></div>

 <div class="para"><p>To find the last client you would simply type <tt>Client.find(:last)</tt> and that would find the last client created in your clients table:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>&gt;&gt; Client.find(:last)

 =&gt; #&lt;Client id: 2, name: =&gt; "Michael", locked: false, orders_count: 3,

-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;

-</tt></pre></div></div>

+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;</tt></pre>

+</div></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

 by Lorenzo Bettini

@@ -422,16 +413,13 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>To find all the clients you would simply type <tt>Client.all</tt> and that would find all the clients in your clients table:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>&gt;&gt; Client.all

 =&gt; [#&lt;Client id: 1, name: =&gt; "Ryan", locked: false, orders_count: 2,

   created_at: "2008-09-28 15:38:50", updated_at: "2008-09-28 15:38:50"&gt;,

   #&lt;Client id: 2, name: =&gt; "Michael", locked: false, orders_count: 3,

-  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;]

-</tt></pre></div></div>

+  created_at: "2008-09-28 13:12:40", updated_at: "2008-09-28 13:12:40"&gt;]</tt></pre>

+</div></div>

 <div class="para"><p>As alternatives to calling <tt>Client.first</tt>, <tt>Client.last</tt>, and <tt>Client.all</tt>, you can use the class methods <tt>Client.first</tt>, <tt>Client.last</tt>, and <tt>Client.all</tt> instead. <tt>Client.first</tt>, <tt>Client.last</tt> and <tt>Client.all</tt> just call their longer counterparts: <tt>Client.find(:first)</tt>, <tt>Client.find(:last)</tt> and <tt>Client.find(:all)</tt> respectively.</p></div>

 <div class="para"><p>Be aware that <tt>Client.first</tt>/<tt>Client.find(:first)</tt> and <tt>Client.last</tt>/<tt>Client.find(:last)</tt> will both return a single object, where as <tt>Client.all</tt>/<tt>Client.find(:all)</tt> will return an array of Client objects, just as passing in an array of ids to find will do also.</p></div>

 </div>

@@ -510,12 +498,9 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>This could possibly cause your database server to raise an unexpected error, for example MySQL will throw back this error:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

-<pre><tt>Got a packet bigger than 'max_allowed_packet' bytes: _query_

-</tt></pre></div></div>

+<div class="content">

+<pre><tt>Got a packet bigger than 'max_allowed_packet' bytes: _query_</tt></pre>

+</div></div>

 <div class="para"><p>Where <em>query</em> is the actual query used to get that error.</p></div>

 <div class="para"><p>In this example it would be better to use greater-than and less-than operators in SQL, like so:</p></div>

 <div class="listingblock">

diff --git a/railties/doc/guides/html/form_helpers.html b/railties/doc/guides/html/form_helpers.html
index 28c317411b..7ff4a13a6a 100644
--- a/railties/doc/guides/html/form_helpers.html
+++ b/railties/doc/guides/html/form_helpers.html
@@ -220,6 +220,16 @@ ul#navMain {
 						
 						</ul>
 					</li>
+					<li>
+					<a href="#_making_select_boxes_with_ease">Making select boxes with ease</a>
+						<ul>
+						
+							<li><a href="#_the_select_tag_and_options">The select tag and options</a></li>
+						
+							<li><a href="#_select_boxes_for_dealing_with_models">Select boxes for dealing with models</a></li>
+						
+						</ul>
+					</li>
 			</ol>
 		</div>
 		
@@ -227,7 +237,7 @@ ul#navMain {
 				<h1>Rails form helpers</h1>
 			<div id="preamble">

 <div class="sectionbody">

-<div class="para"><p>Forms in web applications are an essential interface for user input. They are also often considered the most complex elements of HTML. Rails deals away with these complexities by providing numerous view helpers for generating form markup. However, since they have different use-cases, developers are required to know all the differences between similar helper methods before putting them to use.</p></div>

+<div class="para"><p>Forms in web applications are an essential interface for user input. However, form markup can quickly become tedious to write and maintain because of form control naming and their numerous attributes. Rails deals away with these complexities by providing view helpers for generating form markup. However, since they have different use-cases, developers are required to know all the differences between similar helper methods before putting them to use.</p></div>

 <div class="para"><p>In this guide we will:</p></div>

 <div class="ilist"><ul>

 <li>

@@ -392,7 +402,7 @@ a submit element.
 <td class="icon">

 <img src="./images/icons/warning.png" alt="Warning" />

 </td>

-<td class="content">Do not delimit the second hash without doing so with the first hash, otherwise your method invocation will result in an ugly <tt>expecting tASSOC</tt> syntax error.</td>

+<td class="content">Do not delimit the second hash without doing so with the first hash, otherwise your method invocation will result in an <tt>expecting tASSOC</tt> syntax error.</td>

 </tr></table>

 </div>

 <h3 id="_checkboxes_radio_buttons_and_other_controls">1.3. Checkboxes, radio buttons and other controls</h3>

@@ -431,7 +441,7 @@ output:
 <td class="icon">

 <img src="./images/icons/important.png" alt="Important" />

 </td>

-<td class="content">Always use labels for each checkbox and radio button. They associate text with a specific option, while also providing a larger clickable region.</td>

+<td class="content">Always use labels for each checkbox and radio button. They associate text with a specific option and provide a larger clickable region.</td>

 </tr></table>

 </div>

 <div class="para"><p>Other form controls we might mention are the text area, password input and hidden input:</p></div>

@@ -458,7 +468,7 @@ output:
 </div>

 <h3 id="_how_do_forms_with_put_or_delete_methods_work">1.4. How do forms with PUT or DELETE methods work?</h3>

 <div class="para"><p>Rails framework encourages RESTful design of your applications, which means you'll be making a lot of "PUT" and "DELETE" requests (besides "GET" and "POST"). Still, most browsers <em>don't support</em> methods other than "GET" and "POST" when it comes to submitting forms. How does this work, then?</p></div>

-<div class="para"><p>Rails works around this issue by emulating other methods over POST with a hidden input named <tt>"<em>method"</tt> that is set to reflect the _real</em> method:</p></div>

+<div class="para"><p>Rails works around this issue by emulating other methods over POST with a hidden input named <tt>"_method"</tt> that is set to reflect the wanted method:</p></div>

 <div class="listingblock">

 <div class="content">

 <pre><tt>form_tag(search_path, :method =&gt; "put")

@@ -563,6 +573,64 @@ form_for(@article)</tt></pre>
 </tr></table>

 </div>

 </div>

+<h2 id="_making_select_boxes_with_ease">3. Making select boxes with ease</h2>

+<div class="sectionbody">

+<div class="para"><p>Select boxes in HTML require a significant amount of markup (one <tt>OPTION</tt> element for each option to choose from), therefore it makes the most sense for them to be dynamically generated from data stored in arrays or hashes.</p></div>

+<div class="para"><p>Here is what our wanted markup might look like:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>&lt;select name="city_id" id="city_id"&gt;

+  &lt;option value="1"&gt;Lisabon&lt;/option&gt;

+  &lt;option value="2"&gt;Madrid&lt;/option&gt;

+  ...

+  &lt;option value="12"&gt;Berlin&lt;/option&gt;

+&lt;/select&gt;</tt></pre>

+</div></div>

+<div class="para"><p>Here we have a list of cities where their names are presented to the user, but internally we want to handle just their IDs so we keep them in value attributes. Let's see how Rails can help out here.</p></div>

+<h3 id="_the_select_tag_and_options">3.1. The select tag and options</h3>

+<div class="para"><p>The most generic helper is <tt>select_tag</tt>, which &#8212; as the name implies &#8212; simply generates the <tt>SELECT</tt> tag that encapsulates the options:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>&lt;%= select_tag(:city_id, '&lt;option value="1"&gt;Lisabon&lt;/option&gt;...') %&gt;</tt></pre>

+</div></div>

+<div class="para"><p>This is a start, but it doesn't dynamically create our option tags. We had to pass them in as a string.</p></div>

+<div class="para"><p>We can generate option tags with the <tt>options_for_select</tt> helper:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>&lt;%= options_for_select([['Lisabon', 1], ['Madrid', 2], ...]) %&gt;

+

+output:

+

+&lt;option value="1"&gt;Lisabon&lt;/option&gt;

+&lt;option value="2"&gt;Madrid&lt;/option&gt;

+...</tt></pre>

+</div></div>

+<div class="para"><p>For input data we used a nested array where each element has two elements: visible value (name) and internal value (ID).</p></div>

+<div class="para"><p>Now you can combine <tt>select_tag</tt> and <tt>options_for_select</tt> to achieve the desired, complete markup:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>&lt;%= select_tag(:city_id, options_for_select(...)) %&gt;</tt></pre>

+</div></div>

+<div class="para"><p>Sometimes, depending on our application's needs, we also wish a specific option to be pre-selected. The <tt>options_for_select</tt> helper supports this with an optional second argument:</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>&lt;%= options_for_select(cities_array, 2) %&gt;

+

+output:

+

+&lt;option value="1"&gt;Lisabon&lt;/option&gt;

+&lt;option value="2" selected="selected"&gt;Madrid&lt;/option&gt;

+...</tt></pre>

+</div></div>

+<div class="para"><p>So whenever Rails sees that the internal value of an option being generated matches this value, it will add the <tt>selected</tt> attribute to that option.</p></div>

+<h3 id="_select_boxes_for_dealing_with_models">3.2. Select boxes for dealing with models</h3>

+<div class="para"><p>Until now we've covered how to make generic select boxes, but in most cases our form controls will be tied to a specific database model. So, to continue from our previous examples, let's assume that we have a "Person" model with a <tt>city_id</tt> attribute.</p></div>

+<div class="listingblock">

+<div class="content">

+<pre><tt>...</tt></pre>

+</div></div>

+<div class="para"><p>&#8230;</p></div>

+</div>

 
 		</div>
 	</div>
diff --git a/railties/doc/guides/html/getting_started_with_rails.html b/railties/doc/guides/html/getting_started_with_rails.html
index 797ae2fb3a..1b2eac0ce5 100644
--- a/railties/doc/guides/html/getting_started_with_rails.html
+++ b/railties/doc/guides/html/getting_started_with_rails.html
@@ -1457,51 +1457,57 @@ http://www.gnu.org/software/src-highlite -->
 <div class="para"><p>At this point, it’s worth looking at some of the tools that Rails provides to eliminate duplication in your code. In particular, you can use <em>partials</em> to clean up duplication in views and <em>filters</em> to help with duplication in controllers.</p></div>

 <h3 id="_using_partials_to_eliminate_view_duplication">7.1. Using Partials to Eliminate View Duplication</h3>

 <div class="para"><p>As you saw earlier, the scaffold-generated views for the <tt>new</tt> and <tt>edit</tt> actions are largely identical. You can pull the shared code out into a <tt>partial</tt> template. This requires editing the new and edit views, and adding a new template:</p></div>

-<div class="para"><p><tt>new.html.erb</tt>:

-[source, ruby]</p></div>

+<div class="para"><p><tt>new.html.erb</tt>:</p></div>

 <div class="listingblock">

-<div class="content">

-<pre><tt>&lt;h1&gt;New post&lt;/h1&gt;

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="color: #FF0000">&lt;h1&gt;</span>New post<span style="color: #FF0000">&lt;/h1&gt;</span>

 

-&lt;%= render :partial =&gt; "form" %&gt;

+<span style="color: #FF0000">&lt;%= render :partial =&gt;</span> <span style="color: #FF0000">"form"</span> <span style="color: #990000">%&gt;</span>

 

-&lt;%= link_to 'Back', posts_path %&gt;</tt></pre>

-</div></div>

-<div class="para"><p><tt>edit.html.erb</tt>:

-[source, ruby]</p></div>

+<span style="color: #FF0000">&lt;%= link_to 'Back', posts_path %&gt;</span>

+</tt></pre></div></div>

+<div class="para"><p><tt>edit.html.erb</tt>:</p></div>

 <div class="listingblock">

-<div class="content">

-<pre><tt>&lt;h1&gt;Editing post&lt;/h1&gt;

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="color: #FF0000">&lt;h1&gt;</span>Editing post<span style="color: #FF0000">&lt;/h1&gt;</span>

 

-&lt;%= render :partial =&gt; "form" %&gt;

+<span style="color: #FF0000">&lt;%= render :partial =&gt;</span> <span style="color: #FF0000">"form"</span> <span style="color: #990000">%&gt;</span>

 

-&lt;%= link_to 'Show', @post %&gt; |

-&lt;%= link_to 'Back', posts_path %&gt;</tt></pre>

-</div></div>

-<div class="para"><p><tt>_form.html.erb</tt>:

-[source, ruby]</p></div>

+<span style="color: #FF0000">&lt;%= link_to 'Show', @post %&gt;</span> <span style="color: #990000">|</span>

+<span style="color: #FF0000">&lt;%= link_to 'Back', posts_path %&gt;</span>

+</tt></pre></div></div>

+<div class="para"><p><tt>_form.html.erb</tt>:</p></div>

 <div class="listingblock">

-<div class="content">

-<pre><tt>&lt;% form_for(@post) do |f| %&gt;

-  &lt;%= f.error_messages %&gt;

-

-  &lt;p&gt;

-    &lt;%= f.label :name %&gt;&lt;br /&gt;

-    &lt;%= f.text_field :name %&gt;

-  &lt;/p&gt;

-  &lt;p&gt;

-    &lt;%= f.label :title, "title" %&gt;&lt;br /&gt;

-    &lt;%= f.text_field :title %&gt;

-  &lt;/p&gt;

-  &lt;p&gt;

-    &lt;%= f.label :content %&gt;&lt;br /&gt;

-    &lt;%= f.text_area :content %&gt;

-  &lt;/p&gt;

-  &lt;p&gt;

-    &lt;%= f.submit "Save" %&gt;

-  &lt;/p&gt;

-&lt;% end %&gt;</tt></pre>

-</div></div>

+<div class="content"><!-- Generator: GNU source-highlight 2.9

+by Lorenzo Bettini

+http://www.lorenzobettini.it

+http://www.gnu.org/software/src-highlite -->

+<pre><tt><span style="color: #FF0000">&lt;% form_for(@post) do |f| %&gt;</span>

+  <span style="color: #FF0000">&lt;%= f.error_messages %&gt;</span>

+

+  <span style="color: #FF0000">&lt;p&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.label :name %&gt;&lt;br /&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.text_field :name %&gt;</span>

+  <span style="color: #FF0000">&lt;/p&gt;</span>

+  <span style="color: #FF0000">&lt;p&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.label :title, "title" %&gt;&lt;br /&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.text_field :title %&gt;</span>

+  <span style="color: #FF0000">&lt;/p&gt;</span>

+  <span style="color: #FF0000">&lt;p&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.label :content %&gt;&lt;br /&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.text_area :content %&gt;</span>

+  <span style="color: #FF0000">&lt;/p&gt;</span>

+  <span style="color: #FF0000">&lt;p&gt;</span>

+    <span style="color: #FF0000">&lt;%= f.submit "Save" %&gt;</span>

+  <span style="color: #FF0000">&lt;/p&gt;</span>

+<span style="color: #FF0000">&lt;% end %&gt;</span>

+</tt></pre></div></div>

 <div class="para"><p>Now, when Rails renders the <tt>new</tt> or <tt>edit</tt> view, it will insert the <tt>_form</tt> partial at the indicated point. Note the naming convention for partials: if you refer to a partial named <tt>form</tt> inside of a view, the corresponding file is <tt>_form.html.erb</tt>, with a leading underscore.</p></div>

 <div class="para"><p>For more information on partials, refer to the <a href="../layouts_and_rendering.html">Layouts and Rending in Rails</a> guide.</p></div>

 <h3 id="_using_filters_to_eliminate_controller_duplication">7.2. Using Filters to Eliminate Controller Duplication</h3>

@@ -1721,32 +1727,32 @@ http://www.gnu.org/software/src-highlite -->
 </li>

 <li>

 <p>

-+app/helpers/comments_helper.rb - A view helper file

+<tt>app/helpers/comments_helper.rb</tt> - A view helper file

 </p>

 </li>

 <li>

 <p>

-+app/views/comments/index.html.erb - The view for the index action

+<tt>app/views/comments/index.html.erb</tt> - The view for the index action

 </p>

 </li>

 <li>

 <p>

-+app/views/comments/show.html.erb - The view for the show action

+<tt>app/views/comments/show.html.erb</tt> - The view for the show action

 </p>

 </li>

 <li>

 <p>

-+app/views/comments/new.html.erb - The view for the new action

+<tt>app/views/comments/new.html.erb</tt> - The view for the new action

 </p>

 </li>

 <li>

 <p>

-+app/views/comments/edit.html.erb - The view for the edit action

+<tt>app/views/comments/edit.html.erb</tt> - The view for the edit action

 </p>

 </li>

 <li>

 <p>

-+test/functional/comments_controller_test.rb - The functional tests for the controller

+<tt>test/functional/comments_controller_test.rb</tt> - The functional tests for the controller

 </p>

 </li>

 </ul></div>

@@ -1984,7 +1990,7 @@ http://www.gnu.org/software/src-highlite -->
 <div class="ilist"><ul>

 <li>

 <p>

-The [http://manuals.rubyonrails.org/]Ruby On Rails guides

+The <a href="http://manuals.rubyonrails.org/">Ruby On Rails guides</a>

 </p>

 </li>

 <li>

@@ -2003,6 +2009,19 @@ The <a href="http://wiki.rubyonrails.org/rails">Rails wiki</a>
 </p>

 </li>

 </ul></div>

+<div class="para"><p>Rails also comes with built-in help that you can generate using the rake command-line utility:</p></div>

+<div class="ilist"><ul>

+<li>

+<p>

+Running <tt>rake doc:guides</tt> will put a full copy of the Rails Guides in the <tt>/doc/guides</tt> folder of your application. Open <tt>/doc/guides/index.html</tt> in your web browser to explore the Guides.

+</p>

+</li>

+<li>

+<p>

+Running <tt>rake doc:rails</tt> will put a full copy of the API documentation for Rails in the <tt>/doc/api</tt> folder of your application. Open <tt>/doc/api/index.html</tt> in your web browser to explore the API documentation.

+</p>

+</li>

+</ul></div>

 </div>

 <h2 id="_changelog">10. Changelog</h2>

 <div class="sectionbody">

@@ -2010,6 +2029,11 @@ The <a href="http://wiki.rubyonrails.org/rails">Rails wiki</a>
 <div class="ilist"><ul>

 <li>

 <p>

+November 3, 2008: Formatting patch from Dave Rothlisberger

+</p>

+</li>

+<li>

+<p>

 November 1, 2008: First approved version by <a href="../authors.html#mgunderloy">Mike Gunderloy</a>

 </p>

 </li>

diff --git a/railties/doc/guides/html/index.html b/railties/doc/guides/html/index.html
index 306257678b..991b10c7e8 100644
--- a/railties/doc/guides/html/index.html
+++ b/railties/doc/guides/html/index.html
@@ -250,7 +250,7 @@ ul#navMain {
 <div class="sidebar-content">

 <div class="sidebar-title"><a href="layouts_and_rendering.html">Layouts and Rendering in Rails</a></div>

 <div class="para"><p>This guide covers the basic layout features of Action Controller and Action View,

-including rendering and redirecting, using +content_for_ blocks, and working

+including rendering and redirecting, using <tt>content_for</tt> blocks, and working

 with partials.</p></div>

 </div></div>

 <div class="sidebarblock">

@@ -276,14 +276,6 @@ understand how to use routing in your own Rails applications, start here.</p></d
 <div class="sidebarblock">

 <div class="sidebar-content">

 <div class="sidebar-title"><a href="actioncontroller_basics.html">Basics of Action Controller</a></div>

-<div class="admonitionblock">

-<table><tr>

-<td class="icon">

-<img src="./images/icons/caution.png" alt="Caution" />

-</td>

-<td class="content"><a href="http://rails.lighthouseapp.com/projects/16213/tickets/17">Lighthouse Ticket</a></td>

-</tr></table>

-</div>

 <div class="para"><p>This guide covers how controllers work and how they fit into the request cycle in your application. It includes sessions, filters, and cookies, data streaming, and dealing with exceptions raised by a request, among other topics.</p></div>

 </div></div>

 <div class="sidebarblock">

@@ -318,20 +310,12 @@ Enjoy.</p></div>
 <div class="sidebarblock">

 <div class="sidebar-content">

 <div class="sidebar-title"><a href="security.html">Securing Rails Applications</a></div>

-<div class="para"><p>This manual describes common security problems in web applications and how to

+<div class="para"><p>This guide describes common security problems in web applications and how to

 avoid them with Rails.</p></div>

 </div></div>

 <div class="sidebarblock">

 <div class="sidebar-content">

 <div class="sidebar-title"><a href="debugging_rails_applications.html">Debugging Rails Applications</a></div>

-<div class="admonitionblock">

-<table><tr>

-<td class="icon">

-<img src="./images/icons/caution.png" alt="Caution" />

-</td>

-<td class="content"><a href="http://rails.lighthouseapp.com/projects/16213/tickets/5">Lighthouse Ticket</a></td>

-</tr></table>

-</div>

 <div class="para"><p>This guide describes how to debug Rails applications. It covers the different

 ways of achieving this and how to understand what is happening "behind the scenes"

 of your code.</p></div>

diff --git a/railties/doc/guides/html/migrations.html b/railties/doc/guides/html/migrations.html
index fd466d3a02..5d0f450634 100644
--- a/railties/doc/guides/html/migrations.html
+++ b/railties/doc/guides/html/migrations.html
@@ -717,7 +717,7 @@ version is the numerical prefix on the migration's filename. For example to migr
 <div class="content">

 <pre><tt>rake db:rollback STEP=3</tt></pre>

 </div></div>

-<div class="para"><p>will run the <tt>down</tt> method fron the last 3 migrations.</p></div>

+<div class="para"><p>will run the <tt>down</tt> method from the last 3 migrations.</p></div>

 <div class="para"><p>The <tt>db:migrate:redo</tt> task is a shortcut for doing a rollback and then migrating back up again. As with the <tt>db:rollback</tt> task you can use the <tt>STEP</tt> parameter if you need to go more than one version back, for example</p></div>

 <div class="listingblock">

 <div class="content">

diff --git a/railties/doc/guides/html/testing_rails_applications.html b/railties/doc/guides/html/testing_rails_applications.html
index 73634ef328..666d1dff85 100644
--- a/railties/doc/guides/html/testing_rails_applications.html
+++ b/railties/doc/guides/html/testing_rails_applications.html
@@ -233,7 +233,7 @@ ul#navMain {
 						
 							<li><a href="#_what_to_include_in_your_functional_tests">What to include in your Functional Tests</a></li>
 						
-							<li><a href="#_available_request_types_for_functional_tests">Available Request Types for Functional Tests===</a></li>
+							<li><a href="#_available_request_types_for_functional_tests">Available Request Types for Functional Tests</a></li>
 						
 							<li><a href="#_the_4_hashes_of_the_apocalypse">The 4 Hashes of the Apocalypse</a></li>
 						
@@ -398,15 +398,12 @@ steve<span style="color: #990000">:</span>
 <div class="para"><p>Fixtures can also be described using the all-too-familiar comma-separated value (CSV) file format. These files, just like YAML fixtures, are placed in the <em>test/fixtures</em> directory, but these end with the <tt>.csv</tt> file extension (as in <tt>celebrity_holiday_figures.csv</tt>).</p></div>

 <div class="para"><p>A CSV fixture looks like this:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>id, username, password, stretchable, comments

 1, sclaus, ihatekids, false, I like to say ""Ho! Ho! Ho!""

 2, ebunny, ihateeggs, true, Hoppity hop y'all

-3, tfairy, ilovecavities, true, "Pull your teeth, I will"

-</tt></pre></div></div>

+3, tfairy, ilovecavities, true, "Pull your teeth, I will"</tt></pre>

+</div></div>

 <div class="para"><p>The first line is the header. It is a comma-separated list of fields. The rest of the file is the payload: 1 record per line. A few notes about this format:</p></div>

 <div class="ilist"><ul>

 <li>

@@ -535,17 +532,14 @@ email<span style="color: #990000">(</span>david<span style="color: #990000">.</s
 <div class="para"><p>In Rails, unit tests are what you write to test your models.</p></div>

 <div class="para"><p>When you create a model using <tt>script/generate</tt>, among other things it creates a test stub in the <tt>test/unit</tt> folder, as well as a fixture for the model:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>$ script/generate model Post

 ...

 create  app/models/post.rb

 create  test/unit/post_test.rb

 create  test/fixtures/posts.yml

-...

-</tt></pre></div></div>

+...</tt></pre>

+</div></div>

 <div class="para"><p>The default test stub in <tt>test/unit/post_test.rb</tt> looks like this:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -637,10 +631,7 @@ Finished <span style="font-weight: bold"><span style="color: #0000FF">in</span><
 <div class="para"><p>This will run all the test methods from the test case.</p></div>

 <div class="para"><p>You can also run a particular test method from the test case by using the <tt>-n</tt> switch with the <tt>test method name</tt>.</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>$ ruby unit/post_test.rb -n test_truth

 

 Loaded suite unit/post_test

@@ -648,8 +639,8 @@ Started
 .

 Finished in 0.023513 seconds.

 

-1 tests, 1 assertions, 0 failures, 0 errors

-</tt></pre></div></div>

+1 tests, 1 assertions, 0 failures, 0 errors</tt></pre>

+</div></div>

 <div class="para"><p>The <tt>.</tt> (dot) above indicates a passing test. When a test fails you see an <tt>F</tt>; when a test throws an error you see an <tt>E</tt> in its place. The last line of the output is the summary.</p></div>

 <div class="para"><p>To see how a test failure is reported, you can add a failing test to the <tt>post_test.rb</tt> test case:</p></div>

 <div class="listingblock">

@@ -664,10 +655,7 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>If you haven't added any data to the test fixture for posts, this test will fail. You can see this by running it:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>$ ruby unit/post_test.rb

 Loaded suite unit/post_test

 Started

@@ -681,8 +669,8 @@ test_should_have_atleast_one_post(PostTest)
      /opt/local/lib/ruby/gems/1.8/gems/activesupport-2.1.1/lib/active_support/testing/setup_and_teardown.rb:33:in `run']:

 &lt;nil&gt; expected to not be nil.

 

-2 tests, 2 assertions, 1 failures, 0 errors

-</tt></pre></div></div>

+2 tests, 2 assertions, 1 failures, 0 errors</tt></pre>

+</div></div>

 <div class="para"><p>In the output, <tt>F</tt> denotes a failure. You can see the corresponding trace shown under <tt>1)</tt> along with the name of the failing test. The next few lines contain the stack trace followed by a message which mentions the actual value and the expected value by the assertion. The default assertion messages provide just enough information to help pinpoint the error. To make the assertion failure message more readable every assertion provides an optional message parameter, as shown here:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -696,10 +684,7 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>Running this test shows the friendlier assertion message:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>$ ruby unit/post_test.rb

 Loaded suite unit/post_test

 Started

@@ -714,8 +699,8 @@ test_should_have_atleast_one_post(PostTest)
 Should not be nil as Posts table should have atleast one post.

 &lt;nil&gt; expected to not be nil.

 

-2 tests, 2 assertions, 1 failures, 0 errors

-</tt></pre></div></div>

+2 tests, 2 assertions, 1 failures, 0 errors</tt></pre>

+</div></div>

 <div class="para"><p>To see how an error gets reported, here's a test containing an error:</p></div>

 <div class="listingblock">

 <div class="content"><!-- Generator: GNU source-highlight 2.9

@@ -730,10 +715,7 @@ http://www.gnu.org/software/src-highlite -->
 </tt></pre></div></div>

 <div class="para"><p>Now you can see even more output in the console from running the tests:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>$ ruby unit/post_test.rb

 Loaded suite unit/post_test

 Started

@@ -756,8 +738,8 @@ NameError: undefined local variable or method `some_undefined_variable' for #&lt
     /opt/local/lib/ruby/gems/1.8/gems/activesupport-2.1.1/lib/active_support/testing/setup_and_teardown.rb:33:in `__send__'

     /opt/local/lib/ruby/gems/1.8/gems/activesupport-2.1.1/lib/active_support/testing/setup_and_teardown.rb:33:in `run'

 

-3 tests, 2 assertions, 1 failures, 1 errors

-</tt></pre></div></div>

+3 tests, 2 assertions, 1 failures, 1 errors</tt></pre>

+</div></div>

 <div class="para"><p>Notice the <em>E</em> in the output. It denotes a test with error.</p></div>

 <div class="admonitionblock">

 <table><tr>

@@ -1160,7 +1142,7 @@ http://www.lorenzobettini.it
 http://www.gnu.org/software/src-highlite -->

 <pre><tt>get<span style="color: #990000">(:</span>view<span style="color: #990000">,</span> <span style="color: #FF0000">{</span><span style="color: #FF0000">'id'</span> <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">'12'</span><span style="color: #FF0000">}</span><span style="color: #990000">,</span> <span style="font-weight: bold"><span style="color: #0000FF">nil</span></span><span style="color: #990000">,</span> <span style="color: #FF0000">{</span><span style="color: #FF0000">'message'</span> <span style="color: #990000">=&gt;</span> <span style="color: #FF0000">'booya!'</span><span style="color: #FF0000">}</span><span style="color: #990000">)</span>

 </tt></pre></div></div>

-<h3 id="_available_request_types_for_functional_tests">4.2. Available Request Types for Functional Tests===</h3>

+<h3 id="_available_request_types_for_functional_tests">4.2. Available Request Types for Functional Tests</h3>

 <div class="para"><p>If you're familiar with the HTTP protocol, you'll know that <tt>get</tt> is a type of request. There are 5 request types supported in Rails functional tests:</p></div>

 <div class="ilist"><ul>

 <li>

@@ -1638,16 +1620,13 @@ http://www.gnu.org/software/src-highlite -->
 <div class="para"><p>In this test, <tt>@expected</tt> is an instance of <tt>TMail::Mail</tt> that you can use in your tests. It is defined in <tt>ActionMailer::TestCase</tt>. The test above uses <tt>@expected</tt> to construct an email, which it then asserts with email created by the custom mailer. The <tt>invite</tt> fixture is the body of the email and is used as the sample content to assert against. The helper <tt>read_fixture</tt> is used to read in the content from this file.</p></div>

 <div class="para"><p>Here's the content of the <tt>invite</tt> fixture:</p></div>

 <div class="listingblock">

-<div class="content"><!-- Generator: GNU source-highlight 2.9

-by Lorenzo Bettini

-http://www.lorenzobettini.it

-http://www.gnu.org/software/src-highlite -->

+<div class="content">

 <pre><tt>Hi friend@example.com,

 

 You have been invited.

 

-Cheers!

-</tt></pre></div></div>

+Cheers!</tt></pre>

+</div></div>

 <div class="para"><p>This is the right time to understand a little more about writing tests for your mailers. The line <tt>ActionMailer::Base.delivery_method = :test</tt> in <tt>config/environments/test.rb</tt> sets the delivery method to test mode so that email will not actually be delivered (useful to avoid spamming your users while testing) but instead it will be appended to an array (<tt>ActionMailer::Base.deliveries</tt>).</p></div>

 <div class="para"><p>However often in unit tests, mails will not actually be sent, simply constructed, as in the example above, where the precise content of the email is checked against what it should be.</p></div>

 <h3 id="_functional_testing">6.3. Functional Testing</h3>

diff --git a/railties/doc/guides/source/2_2_release_notes.txt b/railties/doc/guides/source/2_2_release_notes.txt
index 2e9e9b8aa1..715648b95e 100644
--- a/railties/doc/guides/source/2_2_release_notes.txt
+++ b/railties/doc/guides/source/2_2_release_notes.txt
@@ -44,7 +44,7 @@ The internal documentation of Rails, in the form of code comments, has been impr
 
 All told, the Guides provide tens of thousands of words of guidance for beginning and intermediate Rails developers.
 
-If you want to these generate guides locally, inside your application:
+If you want to generate these guides locally, inside your application:
 
 [source, ruby]
 -------------------------------------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/changelog.txt b/railties/doc/guides/source/actioncontroller_basics/changelog.txt
new file mode 100644
index 0000000000..4ee16af19e
--- /dev/null
+++ b/railties/doc/guides/source/actioncontroller_basics/changelog.txt
@@ -0,0 +1,5 @@
+== Changelog ==
+
+http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/17[Lighthouse ticket]
+
+* November 4, 2008: First release version by Tore Darrell
diff --git a/railties/doc/guides/source/actioncontroller_basics/cookies.txt b/railties/doc/guides/source/actioncontroller_basics/cookies.txt
index d451f3f7a6..88b99de3ee 100644
--- a/railties/doc/guides/source/actioncontroller_basics/cookies.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/cookies.txt
@@ -31,4 +31,4 @@ class CommentsController < ApplicationController
 end
 -----------------------------------------
 
-Note that while for session values, you set the key to `nil`, to delete a cookie value, you use `cookies.delete(:key)`.
+Note that while for session values, you set the key to `nil`, to delete a cookie value, you should use `cookies.delete(:key)`.
diff --git a/railties/doc/guides/source/actioncontroller_basics/csrf.txt b/railties/doc/guides/source/actioncontroller_basics/csrf.txt
new file mode 100644
index 0000000000..87e3d39c88
--- /dev/null
+++ b/railties/doc/guides/source/actioncontroller_basics/csrf.txt
@@ -0,0 +1,32 @@
+== Request Forgery Protection ==
+
+Cross-site request forgery is a type of attack in which a site tricks a user into making requests on another site, possibly adding, modifying or deleting data on that site without the user's knowledge or permission. The first step to avoid this is to make sure all "destructive" actions (create, update and destroy) can only be accessed with non-GET requests. If you're following RESTful conventions you're already doing this. However, a malicious site can still send a non-GET request to your site quite easily, and that's where the request forgery protection comes in. As the name says, it protects from forged requests. The way this is done is to add a non-guessable token which is only known to your server to each request. This way, if a request comes in without the proper token, it will be denied access.
+
+If you generate a form like this:
+
+[source, ruby]
+-----------------------------------------
+<% form_for @user do |f| -%>
+  <%= f.text_field :username %>
+  <%= f.text_field :password -%>
+<% end -%>
+-----------------------------------------
+
+You will see how the token gets added as a hidden field:
+
+[source, html]
+-----------------------------------------
+<form action="/users/1" method="post">
+<div><!-- ... --><input type="hidden" value="67250ab105eb5ad10851c00a5621854a23af5489" name="authenticity_token"/></div>
+<!-- Fields -->
+</form>
+-----------------------------------------
+
+Rails adds this token to every form that's generated using the link:../form_helpers.html[form helpers], so most of the time you don't have to worry about it. If you're writing a form manually or need to add the token for another reason, it's available through the method `form_authenticity_token`:
+
+.Add a JavaScript variable containing the token for use with Ajax
+-----------------------------------------
+<%= javascript_tag "MyApp.authenticity_token = '#{form_authenticity_token}'" %>
+-----------------------------------------
+
+The link:../security.html[Security Guide] has more about this and a lot of other security-related issues that you should be aware of when developing a web application.
diff --git a/railties/doc/guides/source/actioncontroller_basics/filters.txt b/railties/doc/guides/source/actioncontroller_basics/filters.txt
index a6f688d144..df67977efd 100644
--- a/railties/doc/guides/source/actioncontroller_basics/filters.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/filters.txt
@@ -1,6 +1,6 @@
 == Filters ==
 
-Filters are methods that are run before, after or "around" a controller action. For example, one filter might check to see if the logged in user has the right credentials to access that particular controller or action. Filters are inherited, so if you set a filter on ApplicationController, it will be run on every controller in your application. A common, simple filter is one which requires that a user is logged in for an action to be run. Let's define the filter method first:
+Filters are methods that are run before, after or "around" a controller action. For example, one filter might check to see if the logged in user has the right credentials to access that particular controller or action. Filters are inherited, so if you set a filter on ApplicationController, it will be run on every controller in your application. A common, simple filter is one which requires that a user is logged in for an action to be run. You can define the filter method this way:
 
 [source, ruby]
 ---------------------------------
@@ -27,7 +27,7 @@ private
 end
 ---------------------------------
 
-The method simply stores an error message in the flash and redirects to the login form if the user is not logged in. If a before filter (a filter which is run before the action) renders or redirects, the action will not run. If there are additional filters scheduled to run after the rendering/redirecting filter, they are also cancelled. To use this filter in a controller, use the link:http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html#M000704[before_filter] method:
+The method simply stores an error message in the flash and redirects to the login form if the user is not logged in. If a before filter (a filter which is run before the action) renders or redirects, the action will not run. If there are additional filters scheduled to run after the rendering or redirecting filter, they are also cancelled. To use this filter in a controller, use the `before_filter` method:
 
 [source, ruby]
 ---------------------------------
@@ -38,7 +38,7 @@ class ApplicationController < ActionController::Base
 end
 ---------------------------------
 
-In this example, the filter is added to ApplicationController and thus all controllers in the application. This will make everything in the application require the user to be logged in in order to use it. For obvious reasons (the user wouldn't be able to log in in the first place!), not all controllers or actions should require this, so to prevent this filter from running you can use link:http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html#M000711[skip_before_filter] :
+In this example, the filter is added to ApplicationController and thus all controllers in the application. This will make everything in the application require the user to be logged in in order to use it. For obvious reasons (the user wouldn't be able to log in in the first place!), not all controllers or actions should require this. You can prevent this filter from running before particular actions with `skip_before_filter` :
 
 [source, ruby]
 ---------------------------------
@@ -49,9 +49,9 @@ class LoginsController < Application
 end
 ---------------------------------
 
-Now, the LoginsController's "new" and "create" actions will work as before without requiring the user to be logged in. The `:only` option is used to only skip this filter for these actions, and there is also an `:except` option which works the other way. These options can be used when adding filters too, so you can add a filter which only runs for selected actions in the first place.
+Now, the +LoginsController+'s "new" and "create" actions will work as before without requiring the user to be logged in. The `:only` option is used to only skip this filter for these actions, and there is also an `:except` option which works the other way. These options can be used when adding filters too, so you can add a filter which only runs for selected actions in the first place.
 
-=== After filters and around filters ===
+=== After Filters and Around Filters ===
 
 In addition to the before filters, you can run filters after an action has run or both before and after. The after filter is similar to the before filter, but because the action has already been run it has access to the response data that's about to be sent to the client. Obviously, after filters can not stop the action from running. Around filters are responsible for running the action, but they can choose not to, which is the around filter's way of stopping it.
 
@@ -75,11 +75,11 @@ private
 end
 ---------------------------------
 
-=== Other ways to use filters ===
+=== Other Ways to Use Filters ===
 
 While the most common way to use filters is by creating private methods and using *_filter to add them, there are two other ways to do the same thing.
 
-The first is to use a block directly with the *_filter methods. The block receives the controller as an argument, and the `require_login` filter from above could be rewritte to use a block:
+The first is to use a block directly with the *_filter methods. The block receives the controller as an argument, and the `require_login` filter from above could be rewritten to use a block:
 
 [source, ruby]
 ---------------------------------
@@ -92,7 +92,7 @@ end
 
 Note that the filter in this case uses `send` because the `logged_in?` method is private and the filter is not run in the scope of the controller. This is not the recommended way to implement this particular filter, but in more simple cases it might be useful.
 
-The second way is to use a class (actually, any object that responds to the right methods will do) to handle the filtering. This is useful in cases that are more complex than can not be implemented in a readable and reusable way using the two other methods. As an example, we will rewrite the login filter again to use a class:
+The second way is to use a class (actually, any object that responds to the right methods will do) to handle the filtering. This is useful in cases that are more complex than can not be implemented in a readable and reusable way using the two other methods. As an example, you could rewrite the login filter again to use a class:
 
 [source, ruby]
 ---------------------------------
@@ -114,6 +114,6 @@ class LoginFilter
 end
 ---------------------------------
 
-Again, this is not an ideal example for this filter, because it's not run in the scope of the controller but gets it passed as an argument. The filter class has a class method `filter` which gets run before or after the action, depending on if it's a before or after filter. Classes used as around filters can also use the same `filter` method, which will get run in the same way. The method must `yield` to execute the action. Alternatively, it can have both a `before` and an `after` method that are run before and after the action.
+Again, this is not an ideal example for this filter, because it's not run in the scope of the controller but gets the controller passed as an argument. The filter class has a class method `filter` which gets run before or after the action, depending on if it's a before or after filter. Classes used as around filters can also use the same `filter` method, which will get run in the same way. The method must `yield` to execute the action. Alternatively, it can have both a `before` and an `after` method that are run before and after the action.
 
 The Rails API documentation has link:http://api.rubyonrails.org/classes/ActionController/Filters/ClassMethods.html[more information on using filters].
diff --git a/railties/doc/guides/source/actioncontroller_basics/http_auth.txt b/railties/doc/guides/source/actioncontroller_basics/http_auth.txt
index 7df0e635bf..954b8a525e 100644
--- a/railties/doc/guides/source/actioncontroller_basics/http_auth.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/http_auth.txt
@@ -1,6 +1,6 @@
 == HTTP Basic Authentication ==
 
-Rails comes with built-in HTTP Basic authentication. This is an authentication scheme that is supported by the majority of browsers and other HTTP clients. As an example, we will create an administration section which will only be available by entering a username and a password into the browser's HTTP Basic dialog window. Using the built-in authentication is quite easy and only requires you to use one method, link:http://api.rubyonrails.org/classes/ActionController/HttpAuthentication/Basic/ControllerMethods.html#M000610[authenticate_or_request_with_http_basic].
+Rails comes with built-in HTTP Basic authentication. This is an authentication scheme that is supported by the majority of browsers and other HTTP clients. As an example, consider an administration section which will only be available by entering a username and a password into the browser's HTTP Basic dialog window. Using the built-in authentication is quite easy and only requires you to use one method, `authenticate_or_request_with_http_basic`.
 
 [source, ruby]
 -------------------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/index.txt b/railties/doc/guides/source/actioncontroller_basics/index.txt
index 0b884e590b..6865ace97b 100644
--- a/railties/doc/guides/source/actioncontroller_basics/index.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/index.txt
@@ -1,7 +1,15 @@
 Action Controller basics
 =======================
 
-In this guide you will learn how controllers work and how they fit into the request cycle in your application. You will learn how to make use of the many tools provided by Action Controller to work with the session, cookies and filters and how to use the built-in HTTP authentication and data streaming facilities. In the end, we will take a look at some tools that will be useful once your controllers are ready and working, like how to filter sensitive parameters from the log and how to rescue and deal with exceptions that may be raised during the request.
+In this guide you will learn how controllers work and how they fit into the request cycle in your application. After reading this guide, you will be able to:
+
+* Follow the flow of a request through a controller
+* Understand why and how to store data in the session or cookies
+* Work with filters to execute code during request processing
+* Use Action Controller's built-in HTTP authentication
+* Stream data directly to the user's browser
+* Filter sensitive parameters so they do not appear in the application's log
+* Deal with exceptions that may be raised during request processing
 
 include::introduction.txt[]
 
@@ -17,6 +25,8 @@ include::filters.txt[]
 
 include::verification.txt[]
 
+include::csrf.txt[]
+
 include::request_response_objects.txt[]
 
 include::http_auth.txt[]
@@ -26,3 +36,5 @@ include::streaming.txt[]
 include::parameter_filtering.txt[]
 
 include::rescue.txt[]
+
+include::changelog.txt[]
diff --git a/railties/doc/guides/source/actioncontroller_basics/introduction.txt b/railties/doc/guides/source/actioncontroller_basics/introduction.txt
index e4b0953b95..6ea217dbb9 100644
--- a/railties/doc/guides/source/actioncontroller_basics/introduction.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/introduction.txt
@@ -1,7 +1,9 @@
-== What does a controller do? ==
+== What Does a Controller do? ==
 
 Action Controller is the C in MVC. After routing has determined which controller to use for a request, your controller is responsible for making sense of the request and producing the appropriate output. Luckily, Action Controller does most of the groundwork for you and uses smart conventions to make this as straight-forward as possible.
 
 For most conventional RESTful applications, the controller will receive the request (this is invisible to you as the developer), fetch or save data from a model and use a view to create HTML output. If your controller needs to do things a little differently, that's not a problem, this is just the most common way for a controller to work.
 
-A controller can thus be thought of as a middle man between models and views. It makes the model data available to the view so it can display it to the user, and it saves or updates data from the user to the model.
+A controller can thus be thought of as a middle man between models and views. It makes the model data available to the view so it can display that data to the user, and it saves or updates data from the user to the model.
+
+NOTE: For more details on the routing process, see link:../routing_outside_in.html[Rails Routing from the Outside In].
diff --git a/railties/doc/guides/source/actioncontroller_basics/methods.txt b/railties/doc/guides/source/actioncontroller_basics/methods.txt
index 370b492e41..c6ae54a540 100644
--- a/railties/doc/guides/source/actioncontroller_basics/methods.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/methods.txt
@@ -1,10 +1,10 @@
-== Methods and actions ==
+== Methods and Actions ==
 
-A controller is a Ruby class which inherits from ActionController::Base and has methods just like any other class. Usually these methods correspond to actions in MVC, but they can just as well be helpful methods which can be called by actions. When your application receives a request, the routing will determine which controller and action to run. Then an instance of that controller will be created and the method corresponding to the action (the method with the same name as the action) gets run.
+A controller is a Ruby class which inherits from ApplicationController and has methods just like any other class. Usually these methods correspond to actions in MVC, but they can just as well be helpful methods which can be called by actions. When your application receives a request, the routing will determine which controller and action to run. Then Rails creates an instance of that controller and runs the method corresponding to the action (the method with the same name as the action).
 
 [source, ruby]
 ----------------------------------------------
-class ClientsController < ActionController::Base
+class ClientsController < ApplicationController
 
   # Actions are public methods
   def new
@@ -25,7 +25,7 @@ end
 
 Private methods in a controller are also used as filters, which will be covered later in this guide.
 
-As an example, if the user goes to `/clients/new` in your application to add a new client, a ClientsController instance will be created and the `new` method will be run. Note that the empty method from the example above could work just fine because Rails will by default render the `new.html.erb` view unless the action says otherwise. The `new` method could make available to the view a `@client` instance variable by creating a new Client:
+As an example, if the user goes to `/clients/new` in your application to add a new client, Rails will create a ClientsController instance will be created and run the `new` method. Note that the empty method from the example above could work just fine because Rails will by default render the `new.html.erb` view unless the action says otherwise. The `new` method could make available to the view a `@client` instance variable by creating a new Client:
 
 [source, ruby]
 ----------------------------------------------
@@ -35,3 +35,5 @@ end
 ----------------------------------------------
 
 The link:../layouts_and_rendering.html[Layouts & rendering guide] explains this in more detail.
+
+ApplicationController inherits from ActionController::Base, which defines a number of helpful methods. This guide will cover some of these, but if you're curious to see what's in there, you can see all of them in the API documentation or in the source itself.
diff --git a/railties/doc/guides/source/actioncontroller_basics/parameter_filtering.txt b/railties/doc/guides/source/actioncontroller_basics/parameter_filtering.txt
index c4577d4f6d..e29f631038 100644
--- a/railties/doc/guides/source/actioncontroller_basics/parameter_filtering.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/parameter_filtering.txt
@@ -1,6 +1,6 @@
-== Parameter filtering ==
+== Parameter Filtering ==
 
-Rails keeps a log file for each environment (development, test and production) in the "log" folder. These are extremely useful when debugging what's actually going on in your application, but in a live application you may not want every bit of information to be stored in the log file. The link:http://api.rubyonrails.org/classes/ActionController/Base.html#M000837[filter_parameter_logging] method can be used to filter out sensitive information from the log. It works by replacing certain keys in the `params` hash with "[FILTERED]" as they are written to the log. As an example, let's see how to filter all parameters with keys that include "password":
+Rails keeps a log file for each environment (development, test and production) in the "log" folder. These are extremely useful when debugging what's actually going on in your application, but in a live application you may not want every bit of information to be stored in the log file. The `filter_parameter_logging` method can be used to filter out sensitive information from the log. It works by replacing certain values in the `params` hash with "[FILTERED]" as they are written to the log. As an example, let's see how to filter all parameters with keys that include "password":
 
 [source, ruby]
 -------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/params.txt b/railties/doc/guides/source/actioncontroller_basics/params.txt
index 7f494d7c9b..fb380519fd 100644
--- a/railties/doc/guides/source/actioncontroller_basics/params.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/params.txt
@@ -1,14 +1,15 @@
 == Parameters ==
 
-You will probably want to access data sent in by the user or other parameters in your controller actions. There are two kinds of parameters possible in a web application. The first are parameters that are sent as part of the URL, query string parameters. The query string is everything after "?" in the URL. The second type of parameter is usually referred to as POST data. This information usually comes from a HTML form which has been filled in by the user. It's called POST data because it can only be sent as part of an HTTP POST request. Rails does not make any distinction between query string parameters and POST parameters, and both are available in the `params` hash in your controller:
+You will probably want to access data sent in by the user or other parameters in your controller actions. There are two kinds of parameters possible in a web application. The first are parameters that are sent as part of the URL, called query string parameters. The query string is everything after "?" in the URL. The second type of parameter is usually referred to as POST data. This information usually comes from a HTML form which has been filled in by the user. It's called POST data because it can only be sent as part of an HTTP POST request. Rails does not make any distinction between query string parameters and POST parameters, and both are available in the `params` hash in your controller:
 
 [source, ruby]
 -------------------------------------
 class ClientsController < ActionController::Base
 
-  # This action uses query string parameters because it gets run by a HTTP GET request,
-  # but this does not make any difference to the way in which the parameters are accessed.
-  # The URL for this action would look like this in order to list activated clients: /clients?status=activated
+  # This action uses query string parameters because it gets run by a HTTP 
+  # GET request, but this does not make any difference to the way in which 
+  # the parameters are accessed. The URL for this action would look like this 
+  # in order to list activated clients: /clients?status=activated
   def index
     if params[:status] = "activated"
       @clients = Client.activated
@@ -34,12 +35,12 @@ class ClientsController < ActionController::Base
 end
 -------------------------------------
 
-=== Hash and array parameters ===
+=== Hash and Array Parameters ===
 
 The params hash is not limited to one-dimensional keys and values. It can contain arrays and (nested) hashes. To send an array of values, append "[]" to the key name:
 
 -------------------------------------
-GET /clients?ids[]=1&ids[2]&ids[]=3
+GET /clients?ids[]=1&ids[]=2&ids[]=3
 -------------------------------------
 
 The value of `params[:ids]` will now be `["1", "2", "3"]`. Note that parameter values are always strings; Rails makes no attempt to guess or cast the type.
@@ -57,6 +58,32 @@ To send a hash you include the key name inside the brackets:
 
 The value of `params[:client]` when this form is submitted  will be `{:name => "Acme", :phone => "12345", :address => {:postcode => "12345", :city => "Carrot City"}}`. Note the nested hash in `params[:client][:address]`.
 
-=== Routing parameters ===
+=== Routing Parameters ===
 
-The `params` hash will always contain the `:controller` and `:action` keys, but you should use the methods `controller_name` and `action_name` instead to access these values. Any other parameters defined by the routing, such as `:id` will also be available.
+The `params` hash will always contain the `:controller` and `:action` keys, but you should use the methods `controller_name` and `action_name` instead to access these values. Any other parameters defined by the routing, such as `:id` will also be available. As an example, consider a listing of clients where the list can show either active or inactive clients. We can add a route which captures the `:status` parameter in a "pretty" URL:
+
+[source, ruby]
+------------------------------------
+# ...
+map.connect "/clients/:status", :controller => "clients", :action => "index", :foo => "bar"
+# ...
+------------------------------------
+
+In this case, when a user opens the URL `/clients/active`, `params[:status]` will be set to "active". When this route is used, `params[:foo]` will also be set to "bar" just like it was passed in the query string in the same way `params[:action]` will contain "index".
+
+=== `default_url_options` ===
+
+You can set global default parameters that will be used when generating URLs with `default_url_options`. To do this, define a method with that name in your controller:
+
+------------------------------------
+class ApplicationController < ActionController::Base
+
+  #The options parameter is the hash passed in to url_for
+  def default_url_options(options)
+    {:locale => I18n.locale}
+  end
+
+end
+------------------------------------
+
+These options will be used as a starting-point when generating, so it's possible they'll be overridden by url_for. Because this method is defined in the controller, you can define it on ApplicationController so it would be used for all URL generation, or you could define it on only one controller for all URLs generated there.
diff --git a/railties/doc/guides/source/actioncontroller_basics/request_response_objects.txt b/railties/doc/guides/source/actioncontroller_basics/request_response_objects.txt
index 493bd4cb43..250f84bd72 100644
--- a/railties/doc/guides/source/actioncontroller_basics/request_response_objects.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/request_response_objects.txt
@@ -1,13 +1,13 @@
-== The request and response objects ==
+== The +request+ and +response+ Objects ==
 
-In every controller there are two accessor methods pointing to the request and the response objects associated with the request cycle that is currently in execution. The `request` method contains an instance of link:http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html[AbstractRequest] and the `response` method contains the link:http://github.com/rails/rails/tree/master/actionpack/lib/action_controller/response.rb[response object] representing what is going to be sent back to the client.
+In every controller there are two accessor methods pointing to the request and the response objects associated with the request cycle that is currently in execution. The `request` method contains an instance of AbstractRequest and the `response` method returns a +response+ object representing what is going to be sent back to the client.
 
-=== The request ===
+=== The +request+ Object ===
 
-The request object contains a lot of useful information about the request coming in from the client. To get a full list of the available methods, refer to the link:http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html[API documentation].
+The request object contains a lot of useful information about the request coming in from the client. To get a full list of the available methods, refer to the link:http://api.rubyonrails.org/classes/ActionController/AbstractRequest.html[API documentation]. Among the properties that you can access on this object:
 
  * host - The hostname used for this request.
- * domain - The hostname without the first part (usually "www").
+ * domain - The hostname without the first segment (usually "www").
  * format - The content type requested by the client.
  * method - The HTTP method used for the request.
  * get?, post?, put?, delete?, head? - Returns true if the HTTP method is get/post/put/delete/head.
@@ -18,18 +18,26 @@ The request object contains a lot of useful information about the request coming
  * remote_ip - The IP address of the client.
  * url - The entire URL used for the request.
 
-==== path_parameters, query_parameters and request_parameters ====
+==== +path_parameters+, +query_parameters+ and +request_parameters+ ====
 
-TODO: Does this belong here?
+Rails collects all of the parameters sent along with the request in the `params` hash, whether they are sent as part of the query string or the post body. The request object has three accessors that give you access to these parameters depending on where they came from. The `query_parameters` hash contains parameters that were sent as part of the query string while the `request_parameters` hash contains parameters sent as part of the post body. The `path_parameters` hash contains parameters that were recognized by the routing as being part of the path leading to this particular controller and action.
 
-Rails collects all of the parameters sent along with the request in the `params` hash, whether they are sent as part of the query string or the post body. The request object has three accessors that give you access to these parameters depending on where they came from. The `query_parameters` hash contains parameters that were sent as part of the query string while the `request_parameters` hash contains parameters sent as part of the post body. The `path_parameters` hash contains parameters that were recognised by the routing as being part of the path leading to this particular controller and action.
+=== The +response+ Object ===
 
-=== The response ===
-
-The response objects is not usually used directly, but is built up during the execution of the action and rendering of the data that is being sent back to the user, but sometimes - like in an after filter - it can be useful to access the response directly. Some of these accessor methods also have setters, allowing you to change their values.
+The response object is not usually used directly, but is built up during the execution of the action and rendering of the data that is being sent back to the user, but sometimes - like in an after filter - it can be useful to access the response directly. Some of these accessor methods also have setters, allowing you to change their values.
 
  * body - This is the string of data being sent back to the client. This is most often HTML.
  * status - The HTTP status code for the response, like 200 for a successful request or 404 for file not found.
  * location - The URL the client is being redirected to, if any.
  * content_type - The content type of the response.
  * charset - The character set being used for the response. Default is "utf8".
+ * headers - Headers used for the response.
+
+==== Setting Custom Headers ====
+
+If you want to set custom headers for a response then `response.headers` is the place to do it. The headers attribute is a hash which maps header names to their values, and Rails will set some of them - like "Content-Type" - automatically. If you want to add or change a header, just assign it to `headers` with the name and value:
+
+[source, ruby]
+-------------------------------------
+response.headers["Content-Type"] = "application/pdf"
+-------------------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/rescue.txt b/railties/doc/guides/source/actioncontroller_basics/rescue.txt
index ec03006764..3353df617c 100644
--- a/railties/doc/guides/source/actioncontroller_basics/rescue.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/rescue.txt
@@ -2,15 +2,15 @@
 
 Most likely your application is going to contain bugs or otherwise throw an exception that needs to be handled. For example, if the user follows a link to a resource that no longer exists in the database, Active Record will throw the ActiveRecord::RecordNotFound exception. Rails' default exception handling displays a 500 Server Error message for all exceptions. If the request was made locally, a nice traceback and some added information gets displayed so you can figure out what went wrong and deal with it. If the request was remote Rails will just display a simple "500 Server Error" message to the user, or a "404 Not Found" if there was a routing error or a record could not be found. Sometimes you might want to customize how these errors are caught and how they're displayed to the user. There are several levels of exception handling available in a Rails application:
 
-=== The default 500 and 404 templates ===
+=== The Default 500 and 404 Templates ===
 
 By default a production application will render either a 404 or a 500 error message. These messages are contained in static HTML files in the `public` folder, in `404.html` and `500.html` respectively. You can customize these files to add some extra information and layout, but remember that they are static; i.e. you can't use RHTML or layouts in them, just plain HTML.
 
 === `rescue_from` ===
 
-If you want to do something a bit more elaborate when catching errors, you can use link::http://api.rubyonrails.org/classes/ActionController/Rescue/ClassMethods.html#M000620[rescue_from], which handles exceptions of a certain type (or multiple types) in an entire controller and its subclasses. When an exception occurs which is caught by a rescue_from directive, the exception object is passed to the handler. The handler can be a method or a Proc object passed to the `:with` option. You can also use a block directly instead of an explicit Proc object.
+If you want to do something a bit more elaborate when catching errors, you can use `rescue_from`, which handles exceptions of a certain type (or multiple types) in an entire controller and its subclasses. When an exception occurs which is caught by a +rescue_from+ directive, the exception object is passed to the handler. The handler can be a method or a Proc object passed to the `:with` option. You can also use a block directly instead of an explicit Proc object.
 
-Let's see how we can use rescue_from to intercept all ActiveRecord::RecordNotFound errors and do something with them.
+Here's how you can use +rescue_from+ to intercept all ActiveRecord::RecordNotFound errors and do something with them.
 
 [source, ruby]
 -----------------------------------
@@ -27,7 +27,7 @@ private
 end
 -----------------------------------
 
-Of course, this example is anything but elaborate and doesn't improve the default exception handling at all, but once you can catch all those exceptions you're free to do whatever you want with them. For example, you could create custom exception classes that will be thrown when a user doesn't have access to a certain section of your application:
+Of course, this example is anything but elaborate and doesn't improve on the default exception handling at all, but once you can catch all those exceptions you're free to do whatever you want with them. For example, you could create custom exception classes that will be thrown when a user doesn't have access to a certain section of your application:
 
 [source, ruby]
 -----------------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/session.txt b/railties/doc/guides/source/actioncontroller_basics/session.txt
index 467cffbf85..3b69ec82ef 100644
--- a/railties/doc/guides/source/actioncontroller_basics/session.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/session.txt
@@ -7,9 +7,11 @@ Your application has a session for each user in which you can store small amount
  * MemCacheStore - Stores the data in MemCache.
  * ActiveRecordStore - Stores the data in a database using Active Record.
 
-All session stores store the session id in a cookie - there is no other way of passing it to the server. Most stores also use this key to locate the session data on the server.
+All session stores store either the session ID or the entire session in a cookie - Rails does not allow the session ID to be passed in any other way. Most stores also use this key to locate the session data on the server.
 
-The default and recommended store, the Cookie Store, does not store session data on the server, but in the cookie itself. The data is cryptographically signed to make it tamper-proof, but it is not encrypted, so anyone with access to it can read its contents. It can only store about 4kB of data - much less than the others - but this is usually enough. Storing large amounts of data is discouraged no matter which session store your application uses. Expecially discouraged is storing complex objects (anything other than basic Ruby objects, the primary example being model instances) in the session, as the server might not be able to reassemble them between requests, which will result in an error. The Cookie Store has the added advantage that it does not require any setting up beforehand - Rails will generate a "secret key" which will be used to sign the cookie when you create the application.
+The default and recommended store, the Cookie Store, does not store session data on the server, but in the cookie itself. The data is cryptographically signed to make it tamper-proof, but it is not encrypted, so anyone with access to it can read its contents but not edit it. It can only store about 4kB of data - much less than the others - but this is usually enough. Storing large amounts of data is discouraged no matter which session store your application uses. You should especially avoid storing complex objects (anything other than basic Ruby objects, the primary example being model instances) in the session, as the server might not be able to reassemble them between requests, which will result in an error. The Cookie Store has the added advantage that it does not require any setting up beforehand - Rails will generate a "secret key" which will be used to sign the cookie when you create the application.
+
+Read more about session storage in the link:../security.html[Security Guide].
 
 If you need a different session storage mechanism, you can change it in the `config/environment.rb` file:
 
@@ -19,9 +21,9 @@ If you need a different session storage mechanism, you can change it in the `con
 config.action_controller.session_store = :active_record_store
 ------------------------------------------
 
-=== Disabling the session ===
+=== Disabling the Session ===
 
-Sometimes you don't need a session, and you can turn it off to avoid the unnecessary overhead. To do this, use the link:http://api.rubyonrails.org/classes/ActionController/SessionManagement/ClassMethods.html#M000649[session] class method in your controller:
+Sometimes you don't need a session. In this case, you can turn it off to avoid the unnecessary overhead. To do this, use the `session` class method in your controller:
 
 [source, ruby]
 ------------------------------------------
@@ -41,7 +43,7 @@ class LoginsController < ActionController::Base
 end
 ------------------------------------------
 
-Or even a single action:
+Or even for specified actions:
 
 [source, ruby]
 ------------------------------------------
@@ -50,7 +52,7 @@ class ProductsController < ActionController::Base
 end
 ------------------------------------------
 
-=== Accessing the session ===
+=== Accessing the Session ===
 
 In your controller you can access the session through the `session` instance method.
 
@@ -65,7 +67,7 @@ class ApplicationController < ActionController::Base
 private
 
   # Finds the User with the ID stored in the session with the key :current_user_id
-  # This is a common way to do user login in a Rails application; logging in sets the
+  # This is a common way to handle user login in a Rails application; logging in sets the
   # session value and logging out removes it.
   def current_user
     @_current_user ||= session[:current_user_id] && User.find(session[:current_user_id])
@@ -108,11 +110,11 @@ class LoginsController < ApplicationController
 end
 ------------------------------------------
 
-To reset the entire session, use link:http://api.rubyonrails.org/classes/ActionController/Base.html#M000855[reset_session].
+To reset the entire session, use `reset_session`.
 
 === The flash ===
 
-The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for storing error messages etc. It is accessed in much the same way as the session, like a hash. Let's use the act of logging out as an example. The controller can set a message which will be displayed to the user on the next request:
+The flash is a special part of the session which is cleared with each request. This means that values stored there will only be available in the next request, which is useful for storing error messages etc. It is accessed in much the same way as the session, like a hash. Let's use the act of logging out as an example. The controller can send a message which will be displayed to the user on the next request:
 
 [source, ruby]
 ------------------------------------------
@@ -163,7 +165,7 @@ class MainController < ApplicationController
 end
 ------------------------------------------
 
-==== flash.now ====
+==== +flash.now+ ====
 
 By default, adding values to the flash will make them available to the next request, but sometimes you may want to access those values in the same request. For example, if the `create` action fails to save a resource and you render the `new` template directly, that's not going to result in a new request, but you may still want to display a message using the flash. To do this, you can use `flash.now` in the same way you use the normal `flash`:
 
diff --git a/railties/doc/guides/source/actioncontroller_basics/streaming.txt b/railties/doc/guides/source/actioncontroller_basics/streaming.txt
index 41d56935b9..f42480ba25 100644
--- a/railties/doc/guides/source/actioncontroller_basics/streaming.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/streaming.txt
@@ -1,6 +1,6 @@
-== Streaming and file downloads ==
+== Streaming and File Downloads ==
 
-Sometimes you may want to send a file to the user instead of rendering an HTML page. All controllers in Rails have the link:http://api.rubyonrails.org/classes/ActionController/Streaming.html#M000624[send_data] and the link:http://api.rubyonrails.org/classes/ActionController/Streaming.html#M000623[send_file] methods, that will both stream data to the client. `send_file` is a convenience method which lets you provide the name of a file on the disk and it will stream the contents of that file for you.
+Sometimes you may want to send a file to the user instead of rendering an HTML page. All controllers in Rails have the `send_data` and the `send_file` methods, that will both stream data to the client. `send_file` is a convenience method which lets you provide the name of a file on the disk and it will stream the contents of that file for you.
 
 To stream data to the client, use `send_data`:
 
@@ -31,7 +31,7 @@ end
 
 The `download_pdf` action in the example above will call a private method which actually generates the file (a PDF document) and returns it as a string. This string will then be streamed to the client as a file download and a filename will be suggested to the user. Sometimes when streaming files to the user, you may not want them to download the file. Take images, for example, which can be embedded into HTML pages. To tell the browser a file is not meant to be downloaded, you can set the `:disposition` option to "inline". The opposite and default value for this option is "attachment".
 
-=== Sending files ===
+=== Sending Files ===
 
 If you want to send a file that already exists on disk, use the `send_file` method. This is usually not recommended, but can be useful if you want to perform some authentication before letting the user download the file.
 
@@ -50,13 +50,13 @@ end
 
 This will read and stream the file 4Kb at the time, avoiding loading the entire file into memory at once. You can turn off streaming with the `stream` option or adjust the block size with the `buffer_size` option.
 
-WARNING: Be careful when using (or just don't use) "outside" data (params, cookies, etc) to locate the file on disk, as this is a security risk as someone could gain access to files they are not meant to have access to.
+WARNING: Be careful when using (or just don't use) "outside" data (params, cookies, etc) to locate the file on disk, as this is a security risk that might allow someone to gain access to files they are not meant to see.
 
 TIP: It is not recommended that you stream static files through Rails if you can instead keep them in a public folder on your web server. It is much more efficient to let the user download the file directly using Apache or another web server, keeping the request from unnecessarily going through the whole Rails stack.
 
-=== RESTful downloads ===
+=== RESTful Downloads ===
 
-While `send_data` works just fine, if you are creating a RESTful application having separate actions for file downloads is usually not necessary. In REST terminology, the PDF file from the example above can be considered just another representation of the client resource. Rails provides an easy and quite sleek way of doing "RESTful downloads". Let's try to rewrite the example so that the PDF download is a part of the `show` action:
+While `send_data` works just fine, if you are creating a RESTful application having separate actions for file downloads is usually not necessary. In REST terminology, the PDF file from the example above can be considered just another representation of the client resource. Rails provides an easy and quite sleek way of doing "RESTful downloads". Here's how you can rewrite the example so that the PDF download is a part of the `show` action, without any streaming:
 
 [source, ruby]
 ----------------------------
@@ -75,7 +75,7 @@ class ClientsController < ApplicationController
 end
 ----------------------------
 
-In order for this example to work, we have to add the PDF MIME type to Rails. This can be done by adding the following line to the file `config/initializers/mime_types.rb`:
+In order for this example to work, you have to add the PDF MIME type to Rails. This can be done by adding the following line to the file `config/initializers/mime_types.rb`:
 
 [source, ruby]
 ----------------------------
diff --git a/railties/doc/guides/source/actioncontroller_basics/verification.txt b/railties/doc/guides/source/actioncontroller_basics/verification.txt
index 39046eee85..5d8ee6117e 100644
--- a/railties/doc/guides/source/actioncontroller_basics/verification.txt
+++ b/railties/doc/guides/source/actioncontroller_basics/verification.txt
@@ -1,8 +1,8 @@
 == Verification ==
 
-Verifications make sure certain criterias are met in order for a controller or action to run. They can specify that a certain key (or several keys in the form of an array) is present in the `params`, `session` or `flash` hashes or that a certain HTTP method was used or that the request was made using XMLHTTPRequest (Ajax). The default action taken when these criterias are not met is to render a 400 Bad Request response, but you can customize this by specifying a redirect URL or rendering something else and you can also add flash messages and HTTP headers to the response. It is described in the link:http://api.rubyonrails.org/classes/ActionController/Verification/ClassMethods.html[API codumentation] as "essentially a special kind of before_filter".
+Verifications make sure certain criteria are met in order for a controller or action to run. They can specify that a certain key (or several keys in the form of an array) is present in the `params`, `session` or `flash` hashes or that a certain HTTP method was used or that the request was made using XMLHTTPRequest (Ajax). The default action taken when these criteria are not met is to render a 400 Bad Request response, but you can customize this by specifying a redirect URL or rendering something else and you can also add flash messages and HTTP headers to the response. It is described in the link:http://api.rubyonrails.org/classes/ActionController/Verification/ClassMethods.html[API documentation] as "essentially a special kind of before_filter".
 
-Let's see how we can use verification to make sure the user supplies a username and a password in order to log in:
+Here's an example of using verification to make sure the user supplies a username and a password in order to log in:
 
 [source, ruby]
 ---------------------------------------
@@ -34,7 +34,7 @@ class LoginsController < ApplicationController
   verify :params => [:username, :password],
          :render => {:action => "new"},
          :add_flash => {:error => "Username and password required to log in"},
-         :only => :create #Only run this verification for the "create" action
+         :only => :create # Only run this verification for the "create" action
 
 end
 ---------------------------------------
diff --git a/railties/doc/guides/source/active_record_basics.txt b/railties/doc/guides/source/active_record_basics.txt
index 15fc544f25..892adb2d43 100644
--- a/railties/doc/guides/source/active_record_basics.txt
+++ b/railties/doc/guides/source/active_record_basics.txt
@@ -1,7 +1,7 @@
 Active Record Basics
 ====================
 
-Active Record is a design pattern that mitigates the mind-numbing mental gymnastics often needed to get your application to communicate with a database. This guide uses a mix of real-world examples, metaphors and detailed explanations of the actual Rails source code to help you make the most of AcitveRecord.
+Active Record is a design pattern that mitigates the mind-numbing mental gymnastics often needed to get your application to communicate with a database. This guide uses a mix of real-world examples, metaphors and detailed explanations of the actual Rails source code to help you make the most of ActiveRecord.
 
 After reading this guide readers should have a strong grasp of the Active Record pattern and how it can be used with or without Rails. Hopefully, some of the philosophical and theoretical intentions discussed here will also make them a stronger and better developer.
 
diff --git a/railties/doc/guides/source/activerecord_validations_callbacks.txt b/railties/doc/guides/source/activerecord_validations_callbacks.txt
new file mode 100644
index 0000000000..cd698d0c1e
--- /dev/null
+++ b/railties/doc/guides/source/activerecord_validations_callbacks.txt
@@ -0,0 +1,25 @@
+Active Record Validations and Callbacks
+=======================================
+
+This guide teaches you how to work with the lifecycle of your Active Record objects. More precisely, you will learn how to validate the state of your objects before they go into the database and also how to teach them to perform custom operations at certain points of their lifecycles.
+
+After reading this guide and trying out the presented concepts, we hope that you'll be able to:
+
+* Correctly use all the built-in Active Record validation helpers
+* Create your own custom validation methods
+* Work with the error messages generated by the validation proccess
+* Register callback methods that will execute custom operations during your objects lifecycle, for example before/after they are saved.
+* Create special classes that encapsulate common behaviour for your callbacks
+* Create Observers - classes with callback methods specific for each of your models, keeping the callback code outside your models' declarations.
+
+== Active Record Validations
+
+
+
+== Credits
+
+
+
+== Changelog
+
+http://rails.lighthouseapp.com/projects/16213/tickets/26-active-record-validations-and-callbacks
diff --git a/railties/doc/guides/source/authors.txt b/railties/doc/guides/source/authors.txt
index 8d0970e4f6..94dfc4db08 100644
--- a/railties/doc/guides/source/authors.txt
+++ b/railties/doc/guides/source/authors.txt
@@ -23,3 +23,17 @@ Cofounder of http://www.eventioz.com[Eventioz]. He has been using Rails since 20
 Can be found at gmail, twitter, freenode, everywhere as miloops.
 ***********************************************************
 
+.Heiko Webers
+[[hawe]]
+***********************************************************
+Heiko Webers is the founder of http://www.bauland42.de[bauland42], a German web application security consulting and development
+company focused on Ruby on Rails. He blogs at http://www.rorsecurity.info. After 10 years of desktop application development,
+Heiko has rarely looked back.
+***********************************************************
+
+.Tore Darell
+[[toretore]]
+***********************************************************
+Tore Darell is an independent developer based in Menton, France who specialises in cruft-free web applications using Ruby, Rails
+and unobtrusive JavaScript. His home on the internet is his blog http://tore.darell.no/[Sneaky Abstractions].
+***********************************************************
diff --git a/railties/doc/guides/source/configuring.txt b/railties/doc/guides/source/configuring.txt
new file mode 100644
index 0000000000..07b630c59d
--- /dev/null
+++ b/railties/doc/guides/source/configuring.txt
@@ -0,0 +1,225 @@
+Configuring Rails Applications
+==============================
+
+This guide covers the configuration and initialization features available to Rails applications. By referring to this guide, you will be able to:
+
+* Adjust the behavior of your Rails applications
+* Add additional code to be run at application start time
+
+== Locations for Initialization Code
+
+preinitializers
+environment.rb first
+env-specific files
+initializers (load_application_initializers)
+after-initializer
+
+== Using a Preinitializer
+
+== Configuring Rails Components
+
+=== Configuring Active Record
+
+=== Configuring Action Controller
+
+=== Configuring Action View
+
+=== Configuring Action Mailer
+
+=== Configuring Active Resource
+
+=== Configuring Active Support
+
+== Using Initializers
+ organization, controlling load order
+
+== Using an After-Initializer
+
+== Changelog ==
+
+http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/28[Lighthouse ticket]
+
+* November 5, 2008: Rough outline by link:../authors.html#mgunderloy[Mike Gunderloy]
+
+
+actionmailer/lib/action_mailer/base.rb
+257:    cattr_accessor :logger
+267:    cattr_accessor :smtp_settings
+273:    cattr_accessor :sendmail_settings
+276:    cattr_accessor :raise_delivery_errors
+282:    cattr_accessor :perform_deliveries
+285:    cattr_accessor :deliveries
+288:    cattr_accessor :default_charset
+291:    cattr_accessor :default_content_type
+294:    cattr_accessor :default_mime_version
+297:    cattr_accessor :default_implicit_parts_order
+299:    cattr_reader :protected_instance_variables
+
+actionmailer/Rakefile
+36:  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+
+actionpack/lib/action_controller/base.rb
+263:    cattr_reader :protected_instance_variables
+273:    cattr_accessor :asset_host
+279:    cattr_accessor :consider_all_requests_local
+285:    cattr_accessor :allow_concurrency
+317:    cattr_accessor :param_parsers
+321:    cattr_accessor :default_charset
+325:    cattr_accessor :logger
+329:    cattr_accessor :resource_action_separator
+333:    cattr_accessor :resources_path_names
+337:    cattr_accessor :request_forgery_protection_token
+341:    cattr_accessor :optimise_named_routes
+351:    cattr_accessor :use_accept_header
+361:    cattr_accessor :relative_url_root
+
+actionpack/lib/action_controller/caching/pages.rb
+55:          cattr_accessor :page_cache_directory
+58:          cattr_accessor :page_cache_extension
+
+actionpack/lib/action_controller/caching.rb
+37:        cattr_reader :cache_store
+48:        cattr_accessor :perform_caching
+
+actionpack/lib/action_controller/dispatcher.rb
+98:    cattr_accessor :error_file_path
+
+actionpack/lib/action_controller/mime_type.rb
+24:    cattr_reader :html_types, :unverifiable_types
+
+actionpack/lib/action_controller/rescue.rb
+36:      base.cattr_accessor :rescue_responses
+40:      base.cattr_accessor :rescue_templates
+
+actionpack/lib/action_controller/session/active_record_store.rb
+60:        cattr_accessor :data_column_name
+170:        cattr_accessor :connection
+173:        cattr_accessor :table_name
+177:        cattr_accessor :session_id_column
+181:        cattr_accessor :data_column
+282:      cattr_accessor :session_class
+
+actionpack/lib/action_controller/vendor/html-scanner/html/sanitizer.rb
+44:    cattr_accessor :included_tags, :instance_writer => false
+
+actionpack/lib/action_view/base.rb
+189:    cattr_accessor :debug_rjs
+193:    cattr_accessor :warn_cache_misses
+
+actionpack/lib/action_view/helpers/active_record_helper.rb
+7:    cattr_accessor :field_error_proc
+
+actionpack/lib/action_view/helpers/form_helper.rb
+805:    cattr_accessor :default_form_builder
+
+actionpack/lib/action_view/template_handlers/erb.rb
+47:      cattr_accessor :erb_trim_mode
+
+actionpack/test/active_record_unit.rb
+5:  cattr_accessor :able_to_connect
+6:  cattr_accessor :connected
+
+actionpack/test/controller/filters_test.rb
+286:    cattr_accessor :execution_log
+
+actionpack/test/template/form_options_helper_test.rb
+3:TZInfo::Timezone.cattr_reader :loaded_zones
+
+activemodel/lib/active_model/errors.rb
+28:    cattr_accessor :default_error_messages
+
+activemodel/Rakefile
+19:  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+
+activerecord/lib/active_record/attribute_methods.rb
+9:      base.cattr_accessor :attribute_types_cached_by_default, :instance_writer => false
+11:      base.cattr_accessor :time_zone_aware_attributes, :instance_writer => false
+
+activerecord/lib/active_record/base.rb
+394:    cattr_accessor :logger, :instance_writer => false
+443:    cattr_accessor :configurations, :instance_writer => false
+450:    cattr_accessor :primary_key_prefix_type, :instance_writer => false
+456:    cattr_accessor :table_name_prefix, :instance_writer => false
+461:    cattr_accessor :table_name_suffix, :instance_writer => false
+467:    cattr_accessor :pluralize_table_names, :instance_writer => false
+473:    cattr_accessor :colorize_logging, :instance_writer => false
+478:    cattr_accessor :default_timezone, :instance_writer => false
+487:    cattr_accessor :schema_format , :instance_writer => false
+491:    cattr_accessor :timestamped_migrations , :instance_writer => false
+
+activerecord/lib/active_record/connection_adapters/abstract/connection_specification.rb
+11:    cattr_accessor :connection_handler, :instance_writer => false
+
+activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+166:      cattr_accessor :emulate_booleans
+
+activerecord/lib/active_record/fixtures.rb
+498:  cattr_accessor :all_loaded_fixtures
+
+activerecord/lib/active_record/locking/optimistic.rb
+38:        base.cattr_accessor :lock_optimistically, :instance_writer => false
+
+activerecord/lib/active_record/migration.rb
+259:    cattr_accessor :verbose
+
+activerecord/lib/active_record/schema_dumper.rb
+13:    cattr_accessor :ignore_tables 
+
+activerecord/lib/active_record/serializers/json_serializer.rb
+4:      base.cattr_accessor :include_root_in_json, :instance_writer => false
+
+activerecord/Rakefile
+142:  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+
+activerecord/test/cases/lifecycle_test.rb
+61:  cattr_reader :last_inherited
+
+activerecord/test/cases/mixin_test.rb
+9:  cattr_accessor :forced_now_time
+
+activeresource/lib/active_resource/base.rb
+206:    cattr_accessor :logger
+
+activeresource/Rakefile
+43:  rdoc.options << '--line-numbers' << '--inline-source' << '-A cattr_accessor=object'
+
+activesupport/lib/active_support/buffered_logger.rb
+17:    cattr_accessor :silencer
+
+activesupport/lib/active_support/cache.rb
+81:      cattr_accessor :logger
+
+activesupport/lib/active_support/core_ext/class/attribute_accessors.rb
+5:#    cattr_accessor :hair_colors
+10:  def cattr_reader(*syms)
+29:  def cattr_writer(*syms)
+50:  def cattr_accessor(*syms)
+51:    cattr_reader(*syms)
+52:    cattr_writer(*syms)
+
+activesupport/lib/active_support/core_ext/logger.rb
+34:  cattr_accessor :silencer
+
+activesupport/test/core_ext/class/attribute_accessor_test.rb
+6:      cattr_accessor :foo
+7:      cattr_accessor :bar, :instance_writer => false
+
+activesupport/test/core_ext/module/synchronization_test.rb
+6:    @target.cattr_accessor :mutex, :instance_writer => false
+
+railties/doc/guides/html/creating_plugins.html
+786:      cattr_accessor <span style="color: #990000">:</span>yaffle_text_field<span style="color: #990000">,</span> <span style="color: #990000">:</span>yaffle_date_field
+860:      cattr_accessor <span style="color: #990000">:</span>yaffle_text_field<span style="color: #990000">,</span> <span style="color: #990000">:</span>yaffle_date_field
+
+railties/lib/rails_generator/base.rb
+93:      cattr_accessor :logger
+
+railties/Rakefile
+265:  rdoc.options << '--line-numbers' << '--inline-source' << '--accessor' << 'cattr_accessor=object'
+
+railties/test/rails_info_controller_test.rb
+12:    cattr_accessor :local_request
+
+Rakefile
+32:  rdoc.options << '-A cattr_accessor=object'
+
diff --git a/railties/doc/guides/source/debugging_rails_applications.txt b/railties/doc/guides/source/debugging_rails_applications.txt
index 24eb0c0431..b45473fc14 100644
--- a/railties/doc/guides/source/debugging_rails_applications.txt
+++ b/railties/doc/guides/source/debugging_rails_applications.txt
@@ -31,7 +31,6 @@ The `debug` helper will return a <pre>-tag that renders the object using the YAM
 
 You'll see something like this:
 
-[source, log]
 ----------------------------------------------------------------------------
 --- !ruby/object:Post
 attributes:
@@ -64,7 +63,6 @@ The `to_yaml` method converts the method to YAML format leaving it more readable
 
 As a result of this, you will have something like this in your view:
 
-[source, log]
 ----------------------------------------------------------------------------
 --- !ruby/object:Post
 attributes:
@@ -94,13 +92,33 @@ Another useful method for displaying object values is `inspect`, especially when
 
 Will be rendered as follows:
 
-[source, log]
 ----------------------------------------------------------------------------
 [1, 2, 3, 4, 5]
 
 Title: Rails debugging guide
 ----------------------------------------------------------------------------
 
+=== Debugging Javascript
+
+Rails has built-in support to debug RJS, to active it, set `ActionView::Base.debug_rjs` to _true_, this will specify whether RJS responses should be wrapped in a try/catch block that alert()s the caught exception (and then re-raises it).
+
+To enable it, add the following in the `Rails::Initializer do |config|` block inside +environment.rb+:
+
+[source, ruby]
+----------------------------------------------------------------------------
+config.action_view[:debug_rjs] = true
+----------------------------------------------------------------------------
+
+Or, at any time, setting `ActionView::Base.debug_rjs` to _true_:
+
+[source, ruby]
+----------------------------------------------------------------------------
+ActionView::Base.debug_rjs = true
+----------------------------------------------------------------------------
+
+[TIP]
+For more information on debugging javascript refer to link:http://getfirebug.com/[Firebug], the popular debugger for Firefox.
+
 == The Logger
 
 It can also be useful to save information to log files at runtime. Rails maintains a separate log file for each runtime environment.
@@ -183,7 +201,6 @@ end
 
 Here's an example of the log generated by this method:
 
-[source, log]
 ----------------------------------------------------------------------------
 Processing PostsController#create (for 127.0.0.1 at 2008-09-08 11:52:54) [POST]
   Session ID: BAh7BzoMY3NyZl9pZCIlMDY5MWU1M2I1ZDRjODBlMzkyMWI1OTg2NWQyNzViZjYiCmZsYXNoSUM6J0FjdGl
@@ -237,7 +254,6 @@ end
 
 If you see the message in the console or logs:
 
-[source, log]
 ----------------------------------------------------------------------------
 ***** Debugger requested, but was not available: Start server with --debugger to enable *****
 ----------------------------------------------------------------------------
@@ -271,7 +287,7 @@ For example:
 (rdb:7)
 ----------------------------------------------------------------------------
 
-Now it's time to play and dig into your application. A good place to start is by asking the debugger for help... so type: `help` (You didn't see that coming, right?)
+Now it's time to explore and dig into your application. A good place to start is by asking the debugger for help... so type: `help` (You didn't see that coming, right?)
 
 ----------------------------------------------------------------------------
 (rdb:7) help
@@ -610,13 +626,91 @@ You can include any number of these configuration lines inside a `.rdebugrc` fil
 
 Here's a good start for an `.rdebugrc`:
 
-[source, log]
 ----------------------------------------------------------------------------
 set autolist
 set forcestep
 set listsize 25
 ----------------------------------------------------------------------------
 
+== Debugging Memory Leaks
+
+A Ruby application (on Rails or not), can leak memory - either in the Ruby code or at the C code level.
+
+In this section, you will learn how to find and fix such leaks by using Bleak House and Valgrind debugging tools.
+
+=== BleakHouse
+
+link:http://github.com/fauna/bleak_house/tree/master[BleakHouse] is a library for finding memory leaks.
+
+If a Ruby object does not go out of scope, the Ruby Garbage Collector won't sweep it since it is referenced somewhere. Leaks like this can grow slowly and your application will consume more and more memory, gradually affecting the overall system performance. This tool will help you find leaks on the Ruby heap.
+
+To install it run:
+
+----------------------------------------------------------------------------
+sudo gem install bleak_house
+----------------------------------------------------------------------------
+
+Then setup you application for profiling. Then add the following at the bottom of config/environment.rb:
+
+[source, ruby]
+----------------------------------------------------------------------------
+require 'bleak_house' if ENV['BLEAK_HOUSE']
+----------------------------------------------------------------------------
+
+Start a server instance with BleakHouse integration:
+
+----------------------------------------------------------------------------
+RAILS_ENV=production BLEAK_HOUSE=1 ruby-bleak-house ./script/server
+----------------------------------------------------------------------------
+
+Make sure to run a couple hundred requests to get better data samples, then press `CTRL-C`. The server will stop and Bleak House will produce a dumpfile in `/tmp`:
+
+----------------------------------------------------------------------------
+** BleakHouse: working...
+** BleakHouse: complete
+** Bleakhouse: run 'bleak /tmp/bleak.5979.0.dump' to analyze.
+----------------------------------------------------------------------------
+ 
+To analyze it, just run the listed command. The top 20 leakiest lines will be listed: 
+
+----------------------------------------------------------------------------
+  191691 total objects
+  Final heap size 191691 filled, 220961 free
+  Displaying top 20 most common line/class pairs
+  89513 __null__:__null__:__node__
+  41438 __null__:__null__:String
+  2348 /opt/local//lib/ruby/site_ruby/1.8/rubygems/specification.rb:557:Array
+  1508 /opt/local//lib/ruby/gems/1.8/specifications/gettext-1.90.0.gemspec:14:String
+  1021 /opt/local//lib/ruby/gems/1.8/specifications/heel-0.2.0.gemspec:14:String
+   951 /opt/local//lib/ruby/site_ruby/1.8/rubygems/version.rb:111:String
+   935 /opt/local//lib/ruby/site_ruby/1.8/rubygems/specification.rb:557:String
+   834 /opt/local//lib/ruby/site_ruby/1.8/rubygems/version.rb:146:Array
+  ...
+----------------------------------------------------------------------------
+
+This way you can find where your application is leaking memory and fix it.
+
+If link:http://github.com/fauna/bleak_house/tree/master[BleakHouse] doesn't report any heap growth but you still have memory growth, you might have a broken C extension, or real leak in the interpreter. In that case, try using Valgrind to investigate further.
+
+=== Valgrind
+
+link:http://valgrind.org/[Valgrind] is a Linux-only application for detecting C-based memory leaks and race conditions.
+
+There are Valgrind tools that can automatically detect many memory management and threading bugs, and profile your programs in detail. For example, a C extension in the interpreter calls `malloc()` but is doesn't properly call `free()`, this memory won't be available until the app terminates.
+
+For further information on how to install Valgrind and use with Ruby, refer to link:http://blog.evanweaver.com/articles/2008/02/05/valgrind-and-ruby/[Valgrind and Ruby] by Evan Weaver.
+
+== Plugins for Debugging
+
+There are some Rails plugins to help you to find errors and debug your application. Here is a list of useful plugins for debugging:
+
+* link:http://github.com/drnic/rails-footnotes/tree/master[Footnotes]: Every Rails page has footnotes that link give request information and link back to your source via TextMate.
+* link:http://github.com/ntalbott/query_trace/tree/master[Query Trace]: Adds query origin tracing to your logs.
+* link:http://github.com/dan-manges/query_stats/tree/master[Query Stats]: A Rails plugin to track database queries. 
+* link:http://code.google.com/p/query-reviewer/[Query Reviewer]: This rails plugin not only runs "EXPLAIN" before each of your select queries in development, but provides a small DIV in the rendered output of each page with the summary of warnings for each query that it analyzed.
+* link:http://github.com/rails/exception_notification/tree/master[Exception Notifier]: Provides a mailer object and a default set of templates for sending email notifications when errors occur in a Rails application.
+* link:http://github.com/defunkt/exception_logger/tree/master[Exception Logger]: Logs your Rails exceptions in the database and provides a funky web interface to manage them.
+
 == References
 
 * link:http://www.datanoise.com/ruby-debug[ruby-debug Homepage]
@@ -628,10 +722,12 @@ set listsize 25
 * link:http://bashdb.sourceforge.net/ruby-debug.html[Debugging with ruby-debug]
 * link:http://cheat.errtheblog.com/s/rdebug/[ruby-debug cheat sheet]
 * link:http://wiki.rubyonrails.org/rails/pages/HowtoConfigureLogging[Ruby on Rails Wiki: How to Configure Logging]
+* link:http://blog.evanweaver.com/files/doc/fauna/bleak_house/files/README.html[Bleak House Documentation]
 
 == Changelog ==
 
 http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/5[Lighthouse ticket]
 
+* November 3, 2008: Accepted for publication. Added RJS, memory leaks and plugins chapters by link:../authors.html#miloops[Emilio Tagua]
 * October 19, 2008: Copy editing pass by link:../authors.html#mgunderloy[Mike Gunderloy]
 * September 16, 2008: initial version by link:../authors.html#miloops[Emilio Tagua]
diff --git a/railties/doc/guides/source/finders.txt b/railties/doc/guides/source/finders.txt
index 945b527e1d..24d078f9e4 100644
--- a/railties/doc/guides/source/finders.txt
+++ b/railties/doc/guides/source/finders.txt
@@ -68,7 +68,6 @@ If you wanted to find clients with id 1 or 2, you call +Client.find([1,2])+ or +
 SELECT * FROM +clients+ WHERE (+clients+.+id+ IN (1,2)) 
 -------------------------------------------------------
 
-[source,txt]
 -------------------------------------------------------
 >> Client.find(1,2)
 => [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2, 
@@ -81,7 +80,6 @@ Note that if you pass in a list of numbers that the result will be returned as a
 
 If you wanted to find the first client you would simply type +Client.first+ and that would find the first client created in your clients table:
 
-[source,txt]
 -------------------------------------------------------
 >> Client.first
 => #<Client id: 1, name: => "Ryan", locked: false, orders_count: 2, 
@@ -99,7 +97,6 @@ Indicating the query that Rails has performed on your database.
 
 To find the last client you would simply type +Client.find(:last)+ and that would find the last client created in your clients table:
 
-[source,txt]
 -------------------------------------------------------
 >> Client.find(:last)
 => #<Client id: 2, name: => "Michael", locked: false, orders_count: 3, 
@@ -113,7 +110,6 @@ SELECT * FROM clients ORDER BY clients.id DESC LIMIT 1
 
 To find all the clients you would simply type +Client.all+ and that would find all the clients in your clients table:
 
-[source,txt]
 -------------------------------------------------------
 >> Client.all
 => [#<Client id: 1, name: => "Ryan", locked: false, orders_count: 2, 
@@ -192,7 +188,6 @@ SELECT * FROM +users+ WHERE (created_at IN
 
 This could possibly cause your database server to raise an unexpected error, for example MySQL will throw back this error:
 
-[source, txt]
 -------------------------------------------------------
 Got a packet bigger than 'max_allowed_packet' bytes: _query_
 -------------------------------------------------------
diff --git a/railties/doc/guides/source/form_helpers.txt b/railties/doc/guides/source/form_helpers.txt
index 7b0aeb0ed9..88ca74a557 100644
--- a/railties/doc/guides/source/form_helpers.txt
+++ b/railties/doc/guides/source/form_helpers.txt
@@ -2,7 +2,7 @@ Rails form helpers
 ==================
 Mislav Marohnić <mislav.marohnic@gmail.com>
 
-Forms in web applications are an essential interface for user input. They are also often considered the most complex elements of HTML. Rails deals away with these complexities by providing numerous view helpers for generating form markup. However, since they have different use-cases, developers are required to know all the differences between similar helper methods before putting them to use.
+Forms in web applications are an essential interface for user input. However, form markup can quickly become tedious to write and maintain because of form control naming and their numerous attributes. Rails deals away with these complexities by providing view helpers for generating form markup. However, since they have different use-cases, developers are required to know all the differences between similar helper methods before putting them to use.
 
 In this guide we will:
 
@@ -112,7 +112,7 @@ form_tag({:controller => "people", :action => "search"}, :method => "get")
 
 This is a common pitfall when using form helpers, since many of them accept multiple hashes. So in future, if a helper produces unexpected output, make sure that you have delimited the hash parameters properly.
 
-WARNING: Do not delimit the second hash without doing so with the first hash, otherwise your method invocation will result in an ugly `expecting tASSOC` syntax error.
+WARNING: Do not delimit the second hash without doing so with the first hash, otherwise your method invocation will result in an `expecting tASSOC` syntax error.
 
 Checkboxes, radio buttons and other controls
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -149,7 +149,7 @@ output:
   <label for="age_adult">I'm over 21</label>
 ----------------------------------------------------------------------------
 
-IMPORTANT: Always use labels for each checkbox and radio button. They associate text with a specific option, while also providing a larger clickable region.
+IMPORTANT: Always use labels for each checkbox and radio button. They associate text with a specific option and provide a larger clickable region.
 
 Other form controls we might mention are the text area, password input and hidden input:
 
@@ -174,7 +174,7 @@ How do forms with PUT or DELETE methods work?
 
 Rails framework encourages RESTful design of your applications, which means you'll be making a lot of "PUT" and "DELETE" requests (besides "GET" and "POST"). Still, most browsers _don't support_ methods other than "GET" and "POST" when it comes to submitting forms. How does this work, then?
 
-Rails works around this issue by emulating other methods over POST with a hidden input named `"_method"` that is set to reflect the _real_ method:
+Rails works around this issue by emulating other methods over POST with a hidden input named `"_method"` that is set to reflect the wanted method:
 
 ----------------------------------------------------------------------------
 form_tag(search_path, :method => "put")
@@ -267,4 +267,79 @@ form_for(@article)
 
 Notice how the short-style `form_for` invocation is conveniently the same, regardless of the record being new or existing. Record identification is smart enough to figure out if the record is new by asking `record.new_record?`.
 
-WARNING: When you're using STI (single-table inheritance) with your models, you can't rely on record identification on a subclass if only their parent class is declared a resource. You will have to specify the model name, `:url` and `:method` explicitly.
\ No newline at end of file
+WARNING: When you're using STI (single-table inheritance) with your models, you can't rely on record identification on a subclass if only their parent class is declared a resource. You will have to specify the model name, `:url` and `:method` explicitly.
+
+
+Making select boxes with ease
+-----------------------------
+
+Select boxes in HTML require a significant amount of markup (one `OPTION` element for each option to choose from), therefore it makes the most sense for them to be dynamically generated from data stored in arrays or hashes.
+
+Here is what our wanted markup might look like:
+
+----------------------------------------------------------------------------
+<select name="city_id" id="city_id">
+  <option value="1">Lisabon</option>
+  <option value="2">Madrid</option>
+  ...
+  <option value="12">Berlin</option>
+</select>
+----------------------------------------------------------------------------
+
+Here we have a list of cities where their names are presented to the user, but internally we want to handle just their IDs so we keep them in value attributes. Let's see how Rails can help out here.
+
+The select tag and options
+~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+The most generic helper is `select_tag`, which -- as the name implies -- simply generates the `SELECT` tag that encapsulates the options:
+
+----------------------------------------------------------------------------
+<%= select_tag(:city_id, '<option value="1">Lisabon</option>...') %>
+----------------------------------------------------------------------------
+
+This is a start, but it doesn't dynamically create our option tags. We had to pass them in as a string.
+
+We can generate option tags with the `options_for_select` helper:
+
+----------------------------------------------------------------------------
+<%= options_for_select([['Lisabon', 1], ['Madrid', 2], ...]) %>
+
+output:
+
+<option value="1">Lisabon</option>
+<option value="2">Madrid</option>
+...
+----------------------------------------------------------------------------
+
+For input data we used a nested array where each element has two elements: visible value (name) and internal value (ID).
+
+Now you can combine `select_tag` and `options_for_select` to achieve the desired, complete markup:
+
+----------------------------------------------------------------------------
+<%= select_tag(:city_id, options_for_select(...)) %>
+----------------------------------------------------------------------------
+
+Sometimes, depending on our application's needs, we also wish a specific option to be pre-selected. The `options_for_select` helper supports this with an optional second argument:
+
+----------------------------------------------------------------------------
+<%= options_for_select(cities_array, 2) %>
+
+output:
+
+<option value="1">Lisabon</option>
+<option value="2" selected="selected">Madrid</option>
+...
+----------------------------------------------------------------------------
+
+So whenever Rails sees that the internal value of an option being generated matches this value, it will add the `selected` attribute to that option.
+
+Select boxes for dealing with models
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Until now we've covered how to make generic select boxes, but in most cases our form controls will be tied to a specific database model. So, to continue from our previous examples, let's assume that we have a "Person" model with a `city_id` attribute.
+
+----------------------------------------------------------------------------
+...
+----------------------------------------------------------------------------
+
+...
\ No newline at end of file
diff --git a/railties/doc/guides/source/getting_started_with_rails.txt b/railties/doc/guides/source/getting_started_with_rails.txt
index c5bbc9e814..f924d0793a 100644
--- a/railties/doc/guides/source/getting_started_with_rails.txt
+++ b/railties/doc/guides/source/getting_started_with_rails.txt
@@ -751,6 +751,7 @@ At this point, it’s worth looking at some of the tools that Rails provides to
 As you saw earlier, the scaffold-generated views for the +new+ and +edit+ actions are largely identical. You can pull the shared code out into a +partial+ template. This requires editing the new and edit views, and adding a new template:
 
 +new.html.erb+:
+
 [source, ruby]
 -------------------------------------------------------
 <h1>New post</h1>
@@ -761,6 +762,7 @@ As you saw earlier, the scaffold-generated views for the +new+ and +edit+ action
 -------------------------------------------------------
 
 +edit.html.erb+:
+
 [source, ruby]
 -------------------------------------------------------
 <h1>Editing post</h1>
@@ -772,6 +774,7 @@ As you saw earlier, the scaffold-generated views for the +new+ and +edit+ action
 -------------------------------------------------------
 
 +_form.html.erb+:
+
 [source, ruby]
 -------------------------------------------------------
 <% form_for(@post) do |f| %>
@@ -979,12 +982,12 @@ $ 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
+* +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+:
 
@@ -1216,15 +1219,21 @@ Note that each post has its own individual comments collection, accessible as +@
 
 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:
 
-* The [http://manuals.rubyonrails.org/]Ruby On Rails guides
+* The link:http://manuals.rubyonrails.org/[Ruby On Rails guides]
 * The link:http://groups.google.com/group/rubyonrails-talk[Ruby on Rails mailing list]
 * The #rubyonrails channel on irc.freenode.net
 * The link:http://wiki.rubyonrails.org/rails[Rails wiki]
 
+Rails also comes with built-in help that you can generate using the rake command-line utility:
+
+* Running +rake doc:guides+ will put a full copy of the Rails Guides in the +/doc/guides+ folder of your application. Open +/doc/guides/index.html+ in your web browser to explore the Guides.
+* Running +rake doc:rails+ will put a full copy of the API documentation for Rails in the +/doc/api+ folder of your application. Open +/doc/api/index.html+ in your web browser to explore the API documentation.
+
 == Changelog ==
 
 http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/2[Lighthouse ticket]
 
+* November 3, 2008: Formatting patch from Dave Rothlisberger
 * November 1, 2008: First approved version by link:../authors.html#mgunderloy[Mike Gunderloy]
 * October 16, 2008: Revised based on feedback from Pratik Naik by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication)
 * October 13, 2008: First complete draft by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication)
diff --git a/railties/doc/guides/source/index.txt b/railties/doc/guides/source/index.txt
index 05d7deee6a..8828e1d313 100644
--- a/railties/doc/guides/source/index.txt
+++ b/railties/doc/guides/source/index.txt
@@ -42,7 +42,7 @@ This guide covers the find method defined in ActiveRecord::Base, as well as name
 .link:layouts_and_rendering.html[Layouts and Rendering in Rails]
 ***********************************************************
 This guide covers the basic layout features of Action Controller and Action View,
-including rendering and redirecting, using +content_for_ blocks, and working
+including rendering and redirecting, using +content_for+ blocks, and working
 with partials.
 ***********************************************************
 
@@ -65,8 +65,6 @@ understand how to use routing in your own Rails applications, start here.
 
 .link:actioncontroller_basics.html[Basics of Action Controller]
 ***********************************************************
-CAUTION: link:http://rails.lighthouseapp.com/projects/16213/tickets/17[Lighthouse Ticket]
-
 This guide covers how controllers work and how they fit into the request cycle in your application. It includes sessions, filters, and cookies, data streaming, and dealing with exceptions raised by a request, among other topics.
 ***********************************************************
 
@@ -92,14 +90,12 @@ Enjoy.
 
 .link:security.html[Securing Rails Applications]
 ***********************************************************
-This manual describes common security problems in web applications and how to
+This guide describes common security problems in web applications and how to
 avoid them with Rails.
 ***********************************************************
 
 .link:debugging_rails_applications.html[Debugging Rails Applications]
 ***********************************************************
-CAUTION: link:http://rails.lighthouseapp.com/projects/16213/tickets/5[Lighthouse Ticket]
-
 This guide describes how to debug Rails applications. It covers the different
 ways of achieving this and how to understand what is happening "behind the scenes"
 of your code.
diff --git a/railties/doc/guides/source/migrations/rakeing_around.txt b/railties/doc/guides/source/migrations/rakeing_around.txt
index 1fcca0cf24..6d8c43d7a3 100644
--- a/railties/doc/guides/source/migrations/rakeing_around.txt
+++ b/railties/doc/guides/source/migrations/rakeing_around.txt
@@ -25,7 +25,7 @@ This will run the `down` method from the latest migration. If you need to undo s
 rake db:rollback STEP=3
 ------------------
 
-will run the `down` method fron the last 3 migrations.
+will run the `down` method from the last 3 migrations.
 
 The `db:migrate:redo` task is a shortcut for doing a rollback and then migrating back up again. As with the `db:rollback` task you can use the `STEP` parameter if you need to go more than one version back, for example
 
diff --git a/railties/doc/guides/source/testing_rails_applications.txt b/railties/doc/guides/source/testing_rails_applications.txt
index dc7635eff9..31b6fc2cfa 100644
--- a/railties/doc/guides/source/testing_rails_applications.txt
+++ b/railties/doc/guides/source/testing_rails_applications.txt
@@ -89,7 +89,6 @@ Fixtures can also be described using the all-too-familiar comma-separated value
 
 A CSV fixture looks like this:
 
-[source, log]
 --------------------------------------------------------------
 id, username, password, stretchable, comments
 1, sclaus, ihatekids, false, I like to say ""Ho! Ho! Ho!""
@@ -184,7 +183,6 @@ In Rails, unit tests are what you write to test your models.
 
 When you create a model using +script/generate+, among other things it creates a test stub in the +test/unit+ folder, as well as a fixture for the model:
 
-[source, log]
 -------------------------------------------------------
 $ script/generate model Post
 ...
@@ -266,7 +264,6 @@ This will run all the test methods from the test case.
 
 You can also run a particular test method from the test case by using the +-n+ switch with the +test method name+.
 
-[source, log]
 -------------------------------------------------------
 $ ruby unit/post_test.rb -n test_truth
 
@@ -292,7 +289,6 @@ end
 
 If you haven't added any data to the test fixture for posts, this test will fail. You can see this by running it:
 
-[source, log]
 -------------------------------------------------------
 $ ruby unit/post_test.rb              
 Loaded suite unit/post_test
@@ -322,7 +318,6 @@ end
 
 Running this test shows the friendlier assertion message:
 
-[source, log]
 -------------------------------------------------------
 $ ruby unit/post_test.rb
 Loaded suite unit/post_test
@@ -354,7 +349,6 @@ end
 
 Now you can see even more output in the console from running the tests:
 
-[source, log]
 -------------------------------------------------------
 $ ruby unit/post_test.rb
 Loaded suite unit/post_test
@@ -519,7 +513,7 @@ Another example: Calling the +:view+ action, passing an +id+ of 12 as the +param
 get(:view, {'id' => '12'}, nil, {'message' => 'booya!'})
 --------------------------------------------------
 
-=== Available Request Types for Functional Tests===
+=== Available Request Types for Functional Tests ===
 
 If you're familiar with the HTTP protocol, you'll know that +get+ is a type of request. There are 5 request types supported in Rails functional tests:
 
@@ -817,7 +811,6 @@ In this test, +@expected+ is an instance of +TMail::Mail+ that you can use in yo
 
 Here's the content of the +invite+ fixture:
 
-[source, log]
 -------------------------------------------------
 Hi friend@example.com,