Merge branch 'master' of git://github.com/lifo/docrails

Conflicts:
	actionmailer/lib/action_mailer/base.rb
	activesupport/lib/active_support/core_ext/kernel/requires.rb

28 files changed, 86 insertions, 82 deletions

diff --git a/activerecord/lib/active_record/aggregations.rb b/activerecord/lib/active_record/aggregations.rb
index 90d3b58c78..81ddbba51e 100644
--- a/activerecord/lib/active_record/aggregations.rb
+++ b/activerecord/lib/active_record/aggregations.rb
@@ -176,7 +176,7 @@ module ActiveRecord
       #   order in which mappings are defined determine the order in which attributes are sent to the
       #   value class constructor.
       # * <tt>:allow_nil</tt> - Specifies that the value object will not be instantiated when all mapped
-      #   attributes are +nil+.  Setting the value object to +nil+ has the effect of writing +nil+ to all
+      #   attributes are +nil+. Setting the value object to +nil+ has the effect of writing +nil+ to all
       #   mapped attributes.
       #   This defaults to +false+.
       # * <tt>:constructor</tt> - A symbol specifying the name of the constructor method or a Proc that
diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index 4979113b0b..1c7209e64e 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -469,9 +469,9 @@ module ActiveRecord
     # === Association Join Models
     #
     # Has Many associations can be configured with the <tt>:through</tt> option to use an
-    # explicit join model to retrieve the data.  This operates similarly to a
-    # +has_and_belongs_to_many+ association.  The advantage is that you're able to add validations,
-    # callbacks, and extra attributes on the join model.  Consider the following schema:
+    # explicit join model to retrieve the data. This operates similarly to a
+    # +has_and_belongs_to_many+ association. The advantage is that you're able to add validations,
+    # callbacks, and extra attributes on the join model. Consider the following schema:
     #
     #   class Author < ActiveRecord::Base
     #     has_many :authorships
@@ -528,7 +528,7 @@ module ActiveRecord
     #   @group.avatars                                # selects all avatars by going through the User join model.
     #
     # An important caveat with going through +has_one+ or +has_many+ associations on the
-    # join model is that these associations are *read-only*.  For example, the following
+    # join model is that these associations are *read-only*. For example, the following
     # would not work following the previous example:
     #
     #   @group.avatars << Avatar.new   # this would work if User belonged_to Avatar rather than the other way around
@@ -596,7 +596,7 @@ module ActiveRecord
     # === Polymorphic Associations
     #
     # Polymorphic associations on models are not restricted on what types of models they
-    # can be associated with.  Rather, they specify an interface that a +has_many+ association
+    # can be associated with. Rather, they specify an interface that a +has_many+ association
     # must adhere to.
     #
     #   class Asset < ActiveRecord::Base
@@ -610,7 +610,7 @@ module ActiveRecord
     #   @asset.attachable = @post
     #
     # This works by using a type column in addition to a foreign key to specify the associated
-    # record.  In the Asset example, you'd need an +attachable_id+ integer column and an
+    # record. In the Asset example, you'd need an +attachable_id+ integer column and an
     # +attachable_type+ string column.
     #
     # Using polymorphic associations in combination with single table inheritance (STI) is
@@ -666,7 +666,7 @@ module ActiveRecord
     #
     # Consider the following loop using the class above:
     #
-    #   for post in Post.all
+    #   Post.all.each do |post|
     #     puts "Post:            " + post.title
     #     puts "Written by:      " + post.author.name
     #     puts "Last comment on: " + post.comments.first.created_on
@@ -675,7 +675,7 @@ module ActiveRecord
     # To iterate over these one hundred posts, we'll generate 201 database queries. Let's
     # first just optimize it for retrieving the author:
     #
-    #   for post in Post.find(:all, :include => :author)
+    #   Post.find(:all, :include => :author).each do |post|
     #
     # This references the name of the +belongs_to+ association that also used the <tt>:author</tt>
     # symbol. After loading the posts, find will collect the +author_id+ from each one and load
@@ -684,7 +684,7 @@ module ActiveRecord
     #
     # We can improve upon the situation further by referencing both associations in the finder with:
     #
-    #   for post in Post.find(:all, :include => [ :author, :comments ])
+    #   Post.find(:all, :include => [ :author, :comments ]).each do |post|
     #
     # This will load all comments with a single query. This reduces the total number of queries
     # to 3. More generally the number of queries will be 1 plus the number of associations
@@ -692,7 +692,7 @@ module ActiveRecord
     #
     # To include a deep hierarchy of associations, use a hash:
     #
-    #   for post in Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ])
+    #   Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ]).each do |post|
     #
     # That'll grab not only all the comments but all their authors and gravatar pictures.
     # You can mix and match symbols, arrays and hashes in any combination to describe the
@@ -741,7 +741,7 @@ module ActiveRecord
     #   Picture.find(:first, :include => :most_recent_comments).most_recent_comments # => returns all associated comments.
     #
     # When eager loaded, conditions are interpolated in the context of the model class, not
-    # the model instance.  Conditions are lazily interpolated before the actual model exists.
+    # the model instance. Conditions are lazily interpolated before the actual model exists.
     #
     # Eager loading is supported with polymorphic associations.
     #
@@ -765,7 +765,7 @@ module ActiveRecord
     # == Table Aliasing
     #
     # Active Record uses table aliasing in the case that a table is referenced multiple times
-    # in a join.  If a table is referenced only once, the standard table name is used.  The
+    # in a join. If a table is referenced only once, the standard table name is used. The
     # second time, the table is aliased as <tt>#{reflection_name}_#{parent_table_name}</tt>.
     # Indexes are appended for any more successive uses of the table name.
     #
@@ -847,7 +847,7 @@ module ActiveRecord
     # == Bi-directional associations
     #
     # When you specify an association there is usually an association on the associated model
-    # that specifies the same relationship in reverse.  For example, with the following models:
+    # that specifies the same relationship in reverse. For example, with the following models:
     #
     #    class Dungeon < ActiveRecord::Base
     #      has_many :traps
@@ -864,9 +864,9 @@ module ActiveRecord
     #
     # The +traps+ association on +Dungeon+ and the +dungeon+ association on +Trap+ are
     # the inverse of each other and the inverse of the +dungeon+ association on +EvilWizard+
-    # is the +evil_wizard+ association on +Dungeon+ (and vice-versa).  By default,
+    # is the +evil_wizard+ association on +Dungeon+ (and vice-versa). By default,
     # Active Record doesn't know anything about these inverse relationships and so no object
-    # loading optimisation is possible.  For example:
+    # loading optimisation is possible. For example:
     #
     #    d = Dungeon.first
     #    t = d.traps.first
@@ -876,8 +876,8 @@ module ActiveRecord
     #
     # The +Dungeon+ instances +d+ and <tt>t.dungeon</tt> in the above example refer to
     # the same object data from the database, but are actually different in-memory copies
-    # of that data.  Specifying the <tt>:inverse_of</tt> option on associations lets you tell
-    # Active Record about inverse relationships and it will optimise object loading.  For
+    # of that data. Specifying the <tt>:inverse_of</tt> option on associations lets you tell
+    # Active Record about inverse relationships and it will optimise object loading. For
     # example, if we changed our model definitions to:
     #
     #    class Dungeon < ActiveRecord::Base
@@ -1060,7 +1060,7 @@ module ActiveRecord
       #   specify it with this option.
       # [:conditions]
       #   Specify the conditions that the associated objects must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>.  Record creations from
+      #   SQL fragment, such as <tt>price > 5 AND name LIKE 'B%'</tt>. Record creations from
       #   the association are scoped if a hash is used.
       #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published
       #   posts with <tt>@blog.posts.create</tt> or <tt>@blog.posts.build</tt>.
@@ -1075,10 +1075,11 @@ module ActiveRecord
       #   Specify the method that returns the primary key used for the association. By default this is +id+.
       # [:dependent]
       #   If set to <tt>:destroy</tt> all the associated objects are destroyed
-      #   alongside this object by calling their +destroy+ method.  If set to <tt>:delete_all</tt> all associated
-      #   objects are deleted *without* calling their +destroy+ method.  If set to <tt>:nullify</tt> all associated
+      #   alongside this object by calling their +destroy+ method. If set to <tt>:delete_all</tt> all associated
+      #   objects are deleted *without* calling their +destroy+ method. If set to <tt>:nullify</tt> all associated
       #   objects' foreign keys are set to +NULL+ *without* calling their +save+ callbacks. If set to
-      #   <tt>:restrict</tt> this object cannot be deleted if it has any associated object.
+      #   <tt>:restrict</tt> this object raises an <tt>ActiveRecord::DeleteRestrictionError</tt> exception and
+      #   cannot be deleted if it has any associated objects.
       #
       #   If using with the <tt>:through</tt> option, the association on the join model must be
       #   a +belongs_to+, and the records which get deleted are the join records, rather than
@@ -1227,7 +1228,8 @@ module ActiveRecord
       #   If set to <tt>:destroy</tt>, the associated object is destroyed when this object is. If set to
       #   <tt>:delete</tt>, the associated object is deleted *without* calling its destroy method.
       #   If set to <tt>:nullify</tt>, the associated object's foreign key is set to +NULL+.
-      #   Also, association is assigned.
+      #   Also, association is assigned. If set to <tt>:restrict</tt> this object raises an
+      #   <tt>ActiveRecord::DeleteRestrictionError</tt> exception and cannot be deleted if it has any associated object.
       # [:foreign_key]
       #   Specify the foreign key used for the association. By default this is guessed to be the name
       #   of this class in lower-case and "_id" suffixed. So a Person class that makes a +has_one+ association
@@ -1243,7 +1245,7 @@ module ActiveRecord
       #   you want to do a join but not include the joined columns. Do not forget to include the
       #   primary and foreign keys, otherwise it will raise an error.
       # [:through]
-      #   Specifies a Join Model through which to perform the query.  Options for <tt>:class_name</tt>,
+      #   Specifies a Join Model through which to perform the query. Options for <tt>:class_name</tt>,
       #   <tt>:primary_key</tt>, and <tt>:foreign_key</tt> are ignored, as the association uses the
       #   source reflection. You can only use a <tt>:through</tt> query through a <tt>has_one</tt>
       #   or <tt>belongs_to</tt> association on the join model.
@@ -1265,7 +1267,7 @@ module ActiveRecord
       #   By default, only save the associated object if it's a new record.
       # [:inverse_of]
       #   Specifies the name of the <tt>belongs_to</tt> association on the associated object
-      #   that is the inverse of this <tt>has_one</tt> association.  Does not work in combination
+      #   that is the inverse of this <tt>has_one</tt> association. Does not work in combination
       #   with <tt>:through</tt> or <tt>:as</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
@@ -1383,7 +1385,7 @@ module ActiveRecord
       #   will be updated with the current time in addition to the updated_at/on attribute.
       # [:inverse_of]
       #   Specifies the name of the <tt>has_one</tt> or <tt>has_many</tt> association on the associated
-      #   object that is the inverse of this <tt>belongs_to</tt> association.  Does not work in
+      #   object that is the inverse of this <tt>belongs_to</tt> association. Does not work in
       #   combination with the <tt>:polymorphic</tt> options.
       #   See ActiveRecord::Associations::ClassMethods's overview on Bi-directional associations for more detail.
       #
@@ -1403,15 +1405,15 @@ module ActiveRecord
       end
 
       # Specifies a many-to-many relationship with another class. This associates two classes via an
-      # intermediate join table.  Unless the join table is explicitly specified as an option, it is
+      # intermediate join table. Unless the join table is explicitly specified as an option, it is
       # guessed using the lexical order of the class names. So a join between Developer and Project
       # will give the default join table name of "developers_projects" because "D" outranks "P".
-      # Note that this precedence is calculated using the <tt><</tt> operator for String.  This
+      # Note that this precedence is calculated using the <tt><</tt> operator for String. This
       # means that if the strings are of different lengths, and the strings are equal when compared
       # up to the shortest length, then the longer string is considered of higher
-      # lexical precedence than the shorter one.  For example, one would expect the tables "paper_boxes" and "papers"
+      # lexical precedence than the shorter one. For example, one would expect the tables "paper_boxes" and "papers"
       # to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes",
-      # but it in fact generates a join table name of "paper_boxes_papers".  Be aware of this caveat, and use the
+      # but it in fact generates a join table name of "paper_boxes_papers". Be aware of this caveat, and use the
       # custom <tt>:join_table</tt> option if you need to.
       #
       # The join table should not have a primary key or a model associated with it. You must manually generate the
@@ -1513,7 +1515,7 @@ module ActiveRecord
       #   the association will use "project_id" as the default <tt>:association_foreign_key</tt>.
       # [:conditions]
       #   Specify the conditions that the associated object must meet in order to be included as a +WHERE+
-      #   SQL fragment, such as <tt>authorized = 1</tt>.  Record creations from the association are
+      #   SQL fragment, such as <tt>authorized = 1</tt>. Record creations from the association are
       #   scoped if a hash is used.
       #   <tt>has_many :posts, :conditions => {:published => true}</tt> will create published posts with <tt>@blog.posts.create</tt>
       #   or <tt>@blog.posts.build</tt>.
diff --git a/activerecord/lib/active_record/associations/collection_association.rb b/activerecord/lib/active_record/associations/collection_association.rb
index 902ad8cb64..8a028c8996 100644
--- a/activerecord/lib/active_record/associations/collection_association.rb
+++ b/activerecord/lib/active_record/associations/collection_association.rb
@@ -126,7 +126,7 @@ module ActiveRecord
         record
       end
 
-      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # Add +records+ to this association. Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
         result = true
diff --git a/activerecord/lib/active_record/associations/has_many_association.rb b/activerecord/lib/active_record/associations/has_many_association.rb
index 78c5c4b870..7172e89a05 100644
--- a/activerecord/lib/active_record/associations/has_many_association.rb
+++ b/activerecord/lib/active_record/associations/has_many_association.rb
@@ -18,7 +18,7 @@ module ActiveRecord
         #
         # If the association has a counter cache it gets that value. Otherwise
         # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
-        # there's one.  Some configuration options like :group make it impossible
+        # there's one. Some configuration options like :group make it impossible
         # to do an SQL count, in those cases the array count will be used.
         #
         # That does not depend on whether the collection has already been loaded
diff --git a/activerecord/lib/active_record/attribute_methods/read.rb b/activerecord/lib/active_record/attribute_methods/read.rb
index aef99e3129..7d4182291a 100644
--- a/activerecord/lib/active_record/attribute_methods/read.rb
+++ b/activerecord/lib/active_record/attribute_methods/read.rb
@@ -58,7 +58,7 @@ module ActiveRecord
             generated_attribute_methods.module_eval("def _#{attr_name}; #{access_code}; end; alias #{attr_name} _#{attr_name}", __FILE__, __LINE__)
           end
 
-          # Define an attribute reader method.  Cope with nil column.
+          # Define an attribute reader method. Cope with nil column.
           # method_name is the same as attr_name except when a non-standard primary key is used,
           # we still define #id as an accessor for the key
           def define_read_method(method_name, attr_name, column)
diff --git a/activerecord/lib/active_record/autosave_association.rb b/activerecord/lib/active_record/autosave_association.rb
index 48dbe0838a..036d514a03 100644
--- a/activerecord/lib/active_record/autosave_association.rb
+++ b/activerecord/lib/active_record/autosave_association.rb
@@ -161,7 +161,7 @@ module ActiveRecord
       #
       # For performance reasons, we don't check whether to validate at runtime.
       # However the validation and callback methods are lazy and those methods
-      # get created when they are invoked for the very first time.  However,
+      # get created when they are invoked for the very first time. However,
       # this can change, for instance, when using nested attributes, which is
       # called _after_ the association has been defined. Since we don't want
       # the callbacks to get defined multiple times, there are guards that
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
index 3fdbc9fce5..8ffd40f7e5 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb
@@ -165,7 +165,7 @@ module ActiveRecord
         checkin conn if conn
       end
 
-      # If a connection already exists yield it to the block.  If no connection
+      # If a connection already exists yield it to the block. If no connection
       # exists checkout a connection, yield it to the block, and checkin the
       # connection when finished.
       def with_connection
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
index b3eb23bbb3..79134a0f27 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb
@@ -42,7 +42,7 @@ module ActiveRecord
       undef_method :execute
 
       # Executes +sql+ statement in the context of this connection using
-      # +binds+ as the bind substitutes.  +name+ is logged along with
+      # +binds+ as the bind substitutes. +name+ is logged along with
       # the executed +sql+ statement.
       def exec_query(sql, name = 'SQL', binds = [])
       end
@@ -276,7 +276,7 @@ module ActiveRecord
 
       # Set the sequence to the max value of the table's column.
       def reset_sequence!(table, column, sequence = nil)
-        # Do nothing by default.  Implement for PostgreSQL, Oracle, ...
+        # Do nothing by default. Implement for PostgreSQL, Oracle, ...
       end
 
       # Inserts the given fixture into the table. Overridden in adapters that require
diff --git a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
index b4969c29d2..a754f46af0 100644
--- a/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
@@ -4,7 +4,7 @@ module ActiveRecord
   module ConnectionAdapters # :nodoc:
     module SchemaStatements
       # Returns a Hash of mappings from the abstract data types to the native
-      # database types.  See TableDefinition#column for details on the recognized
+      # database types. See TableDefinition#column for details on the recognized
       # abstract data types.
       def native_database_types
         {}
@@ -78,7 +78,7 @@ module ActiveRecord
       # Creates a new table with the name +table_name+. +table_name+ may either
       # be a String or a Symbol.
       #
-      # There are two ways to work with +create_table+.  You can use the block
+      # There are two ways to work with +create_table+. You can use the block
       # form or the regular form, like this:
       #
       # === Block form
@@ -299,7 +299,7 @@ module ActiveRecord
         raise NotImplementedError, "rename_column is not implemented"
       end
 
-      # Adds a new index to the table.  +column_name+ can be a single Symbol, or
+      # Adds a new index to the table. +column_name+ can be a single Symbol, or
       # an Array of Symbols.
       #
       # The index will be named after the table and the first column name,
diff --git a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
index a3704fe54a..8bd9099a36 100644
--- a/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/mysql_adapter.rb
@@ -406,7 +406,7 @@ module ActiveRecord
 
       def exec_without_stmt(sql, name = 'SQL') # :nodoc:
         # Some queries, like SHOW CREATE TABLE don't work through the prepared
-        # statement API.  For those queries, we need to use this method. :'(
+        # statement API. For those queries, we need to use this method. :'(
         log(sql, name) do
           result = @connection.query(sql)
           cols = []
@@ -832,7 +832,7 @@ module ActiveRecord
           stmt.execute(*binds.map { |col, val| type_cast(val, col) })
         rescue Mysql::Error => e
           # Older versions of MySQL leave the prepared statement in a bad
-          # place when an error occurs.  To support older mysql versions, we
+          # place when an error occurs. To support older mysql versions, we
           # need to close the statement and delete the statement from the
           # cache.
           stmt.close
diff --git a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
index f94d52e20e..8b48c055ac 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb
@@ -198,7 +198,7 @@ module ActiveRecord
     # * <tt>:password</tt> - Defaults to nothing.
     # * <tt>:database</tt> - The name of the database. No default, must be provided.
     # * <tt>:schema_search_path</tt> - An optional schema search path for the connection given
-    #   as a string of comma-separated schema names.  This is backward-compatible with the <tt>:schema_order</tt> option.
+    #   as a string of comma-separated schema names. This is backward-compatible with the <tt>:schema_order</tt> option.
     # * <tt>:encoding</tt> - An optional client encoding that is used in a <tt>SET client_encoding TO
     #   <encoding></tt> call on the connection.
     # * <tt>:min_messages</tt> - An optional client min messages that is used in a
@@ -618,7 +618,7 @@ module ActiveRecord
         create_database(name)
       end
 
-      # Create a new PostgreSQL database.  Options include <tt>:owner</tt>, <tt>:template</tt>,
+      # Create a new PostgreSQL database. Options include <tt>:owner</tt>, <tt>:template</tt>,
       # <tt>:encoding</tt>, <tt>:tablespace</tt>, and <tt>:connection_limit</tt> (note that MySQL uses
       # <tt>:charset</tt> while PostgreSQL uses <tt>:encoding</tt>).
       #
diff --git a/activerecord/lib/active_record/counter_cache.rb b/activerecord/lib/active_record/counter_cache.rb
index 7839f03848..4d387565d9 100644
--- a/activerecord/lib/active_record/counter_cache.rb
+++ b/activerecord/lib/active_record/counter_cache.rb
@@ -2,7 +2,7 @@ module ActiveRecord
   # = Active Record Counter Cache
   module CounterCache
     # Resets one or more counter caches to their correct value using an SQL
-    # count query.  This is useful when adding new counter caches, or if the
+    # count query. This is useful when adding new counter caches, or if the
     # counter has been corrupted or modified directly by SQL.
     #
     # ==== Parameters
diff --git a/activerecord/lib/active_record/fixtures.rb b/activerecord/lib/active_record/fixtures.rb
index 1f31722a7c..612a904031 100644
--- a/activerecord/lib/active_record/fixtures.rb
+++ b/activerecord/lib/active_record/fixtures.rb
@@ -54,14 +54,14 @@ class FixturesFileNotFound < StandardError; end
 #     name: Google
 #     url: http://www.google.com
 #
-# This YAML fixture file includes two fixtures.  Each YAML fixture (ie. record) is given a name and is followed by an
-# indented list of key/value pairs in the "key: value" format.  Records are separated by a blank line for your viewing
+# This YAML fixture file includes two fixtures. Each YAML fixture (ie. record) is given a name and is followed by an
+# indented list of key/value pairs in the "key: value" format. Records are separated by a blank line for your viewing
 # pleasure.
 #
 # Note that YAML fixtures are unordered. If you want ordered fixtures, use the omap YAML type.
 # See http://yaml.org/type/omap.html
-# for the specification.  You will need ordered fixtures when you have foreign key constraints on keys in the same table.
-# This is commonly needed for tree structures.  Example:
+# for the specification. You will need ordered fixtures when you have foreign key constraints on keys in the same table.
+# This is commonly needed for tree structures. Example:
 #
 #    --- !omap
 #    - parent:
@@ -75,7 +75,7 @@ class FixturesFileNotFound < StandardError; end
 #
 # = Using fixtures in testcases
 #
-# Since fixtures are a testing construct, we use them in our unit and functional tests.  There are two ways to use the
+# Since fixtures are a testing construct, we use them in our unit and functional tests. There are two ways to use the
 # fixtures, but first let's take a look at a sample unit test:
 #
 #   require 'test_helper'
@@ -558,7 +558,7 @@ module ActiveRecord
       fixtures.size
     end
 
-    # Return a hash of rows to be inserted.  The key is the table, the value is
+    # Return a hash of rows to be inserted. The key is the table, the value is
     # a list of rows to insert to that table.
     def table_rows
       now = ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
diff --git a/activerecord/lib/active_record/locking/pessimistic.rb b/activerecord/lib/active_record/locking/pessimistic.rb
index 4c4c1bf5a1..66994e4797 100644
--- a/activerecord/lib/active_record/locking/pessimistic.rb
+++ b/activerecord/lib/active_record/locking/pessimistic.rb
@@ -14,7 +14,7 @@ module ActiveRecord
     #   Account.transaction do
     #     # select * from accounts where name = 'shugo' limit 1 for update
     #     shugo = Account.where("name = 'shugo'").lock(true).first
-    #     yuko = Account.where("name = 'shugo'").lock(true).first
+    #     yuko = Account.where("name = 'yuko'").lock(true).first
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
diff --git a/activerecord/lib/active_record/migration/command_recorder.rb b/activerecord/lib/active_record/migration/command_recorder.rb
index c9d57ce812..f9f7448008 100644
--- a/activerecord/lib/active_record/migration/command_recorder.rb
+++ b/activerecord/lib/active_record/migration/command_recorder.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   class Migration
     # ActiveRecord::Migration::CommandRecorder records commands done during
-    # a migration and knows how to reverse those commands.  The CommandRecorder
+    # a migration and knows how to reverse those commands. The CommandRecorder
     # knows how to invert the following commands:
     #
     # * add_column
@@ -20,7 +20,7 @@ module ActiveRecord
         @delegate = delegate
       end
 
-      # record +command+.  +command+ should be a method name and arguments.
+      # record +command+. +command+ should be a method name and arguments.
       # For example:
       #
       #   recorder.record(:method_name, [:arg1, arg2])
@@ -29,7 +29,7 @@ module ActiveRecord
       end
 
       # Returns a list that represents commands that are the inverse of the
-      # commands stored in +commands+.  For example:
+      # commands stored in +commands+. For example:
       #
       #   recorder.record(:rename_table, [:old, :new])
       #   recorder.inverse # => [:rename_table, [:new, :old]]
diff --git a/activerecord/lib/active_record/persistence.rb b/activerecord/lib/active_record/persistence.rb
index e84a479a13..4ec0431b8c 100644
--- a/activerecord/lib/active_record/persistence.rb
+++ b/activerecord/lib/active_record/persistence.rb
@@ -137,6 +137,8 @@ module ActiveRecord
     # * Callbacks are skipped.
     # * updated_at/updated_on column is not updated if that column is available.
     #
+    # Raises an +ActiveRecordError+ when called on new objects, or when the +name+
+    # attribute is marked as readonly.
     def update_column(name, value)
       name = name.to_s
       raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
diff --git a/activerecord/lib/active_record/reflection.rb b/activerecord/lib/active_record/reflection.rb
index b1bb1b0f7f..a058e880ca 100644
--- a/activerecord/lib/active_record/reflection.rb
+++ b/activerecord/lib/active_record/reflection.rb
@@ -379,7 +379,7 @@ module ActiveRecord
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
-      # Gets the source of the through reflection.  It checks both a singularized
+      # Gets the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
       #   class Post < ActiveRecord::Base
diff --git a/activerecord/lib/active_record/relation.rb b/activerecord/lib/active_record/relation.rb
index 65e2ad0963..d88e2693b6 100644
--- a/activerecord/lib/active_record/relation.rb
+++ b/activerecord/lib/active_record/relation.rb
@@ -293,7 +293,7 @@ module ActiveRecord
     end
 
     # Destroy an object (or multiple objects) that has the given id, the object is instantiated first,
-    # therefore all callbacks and filters are fired off before the object is deleted.  This method is
+    # therefore all callbacks and filters are fired off before the object is deleted. This method is
     # less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run.
     #
     # This essentially finds the object (or multiple objects) with the given id, creates a new object
@@ -322,7 +322,7 @@ module ActiveRecord
     # Deletes the records matching +conditions+ without instantiating the records first, and hence not
     # calling the +destroy+ method nor invoking callbacks. This is a single SQL DELETE statement that
     # goes straight to the database, much more efficient than +destroy_all+. Be careful with relations
-    # though, in particular <tt>:dependent</tt> rules defined on associations are not honored.  Returns
+    # though, in particular <tt>:dependent</tt> rules defined on associations are not honored. Returns
     # the number of rows affected.
     #
     # ==== Parameters
diff --git a/activerecord/lib/active_record/relation/calculations.rb b/activerecord/lib/active_record/relation/calculations.rb
index 0fcae92d51..a785f38e89 100644
--- a/activerecord/lib/active_record/relation/calculations.rb
+++ b/activerecord/lib/active_record/relation/calculations.rb
@@ -66,7 +66,7 @@ module ActiveRecord
       calculate(:average, column_name, options)
     end
 
-    # Calculates the minimum value on a given column.  The value is returned
+    # Calculates the minimum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # +calculate+ for examples with options.
     #
@@ -93,7 +93,7 @@ module ActiveRecord
       calculate(:sum, column_name, options)
     end
 
-    # This calculates aggregate values in the given column.  Methods for count, sum, average,
+    # This calculates aggregate values in the given column. Methods for count, sum, average,
     # minimum, and maximum have been added as shortcuts. Options such as <tt>:conditions</tt>,
     # <tt>:order</tt>, <tt>:group</tt>, <tt>:having</tt>, and <tt>:joins</tt> can be passed to customize the query.
     #
@@ -101,7 +101,7 @@ module ActiveRecord
     #   * Single aggregate value: The single value is type cast to Fixnum for COUNT, Float
     #     for AVG, and the given column's type for everything else.
     #   * Grouped values: This returns an ordered hash of the values and groups them by the
-    #     <tt>:group</tt> option.  It takes either a column name, or the name of a belongs_to association.
+    #     <tt>:group</tt> option. It takes either a column name, or the name of a belongs_to association.
     #
     #       values = Person.maximum(:age, :group => 'last_name')
     #       puts values["Drake"]
@@ -119,7 +119,7 @@ module ActiveRecord
     # Options:
     # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1" or [ "user_name = ?", username ].
     #   See conditions in the intro to ActiveRecord::Base.
-    # * <tt>:include</tt>: Eager loading, see Associations for details.  Since calculations don't load anything,
+    # * <tt>:include</tt>: Eager loading, see Associations for details. Since calculations don't load anything,
     #   the purpose of this is to access fields on joined tables in your conditions, order, or group clauses.
     # * <tt>:joins</tt> - An SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id".
     #   (Rarely needed).
diff --git a/activerecord/lib/active_record/relation/finder_methods.rb b/activerecord/lib/active_record/relation/finder_methods.rb
index 4659563f33..c6e8762b4a 100644
--- a/activerecord/lib/active_record/relation/finder_methods.rb
+++ b/activerecord/lib/active_record/relation/finder_methods.rb
@@ -83,7 +83,7 @@ module ActiveRecord
     #
     # Example for find with a lock: Imagine two concurrent transactions:
     # each will read <tt>person.visits == 2</tt>, add 1 to it, and save, resulting
-    # in two saves of <tt>person.visits = 3</tt>.  By locking the row, the second
+    # in two saves of <tt>person.visits = 3</tt>. By locking the row, the second
     # transaction has to wait until the first is finished; we get the
     # expected <tt>person.visits == 4</tt>.
     #
diff --git a/activerecord/lib/active_record/result.rb b/activerecord/lib/active_record/result.rb
index 243012f88c..9ceab2eabc 100644
--- a/activerecord/lib/active_record/result.rb
+++ b/activerecord/lib/active_record/result.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   ###
   # This class encapsulates a Result returned from calling +exec_query+ on any
-  # database connection adapter.  For example:
+  # database connection adapter. For example:
   #
   #   x = ActiveRecord::Base.connection.exec_query('SELECT * FROM foo')
   #   x # => #<ActiveRecord::Result:0xdeadbeef>
diff --git a/activerecord/lib/active_record/schema_dumper.rb b/activerecord/lib/active_record/schema_dumper.rb
index a893c0ad85..62e6999736 100644
--- a/activerecord/lib/active_record/schema_dumper.rb
+++ b/activerecord/lib/active_record/schema_dumper.rb
@@ -106,7 +106,7 @@ HEADER
             spec = {}
             spec[:name]      = column.name.inspect
 
-            # AR has an optimisation which handles zero-scale decimals as integers.  This
+            # AR has an optimisation which handles zero-scale decimals as integers. This
             # code ensures that the dumper still dumps the column as a decimal.
             spec[:type]      = if column.type == :integer && [/^numeric/, /^decimal/].any? { |e| e.match(column.sql_type) }
                                  'decimal'
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index 8c4adf7116..f8e6cf958c 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -75,7 +75,7 @@ module ActiveRecord #:nodoc:
     #   </firm>
     #
     # Additionally, the record being serialized will be passed to a Proc's second
-    # parameter.  This allows for ad hoc additions to the resultant document that
+    # parameter. This allows for ad hoc additions to the resultant document that
     # incorporate the context of the record being serialized. And by leveraging the
     # closure created by a Proc, to_xml can be used to add elements that normally fall
     # outside of the scope of the model -- for example, generating and appending URLs
diff --git a/activerecord/lib/active_record/session_store.rb b/activerecord/lib/active_record/session_store.rb
index c3e976002e..929559c3ba 100644
--- a/activerecord/lib/active_record/session_store.rb
+++ b/activerecord/lib/active_record/session_store.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   # = Active Record Session Store
   #
-  # A session store backed by an Active Record class.  A default class is
+  # A session store backed by an Active Record class. A default class is
   # provided, but any object duck-typing to an Active Record Session class
   # with text +session_id+ and +data+ attributes is sufficient.
   #
@@ -23,7 +23,7 @@ module ActiveRecord
   #   ActiveRecord::SessionStore::Session.data_column_name = 'legacy_session_data'
   #
   # Note that setting the primary key to the +session_id+ frees you from
-  # having a separate +id+ column if you don't want it.  However, you must
+  # having a separate +id+ column if you don't want it. However, you must
   # set <tt>session.model.id = session.session_id</tt> by hand!  A before filter
   # on ApplicationController is a good place.
   #
@@ -46,7 +46,7 @@ module ActiveRecord
   #   save
   #   destroy
   #
-  # The example SqlBypass class is a generic SQL session store.  You may
+  # The example SqlBypass class is a generic SQL session store. You may
   # use it as a basis for high-performance database-specific stores.
   class SessionStore < ActionDispatch::Session::AbstractStore
     module ClassMethods # :nodoc:
@@ -79,7 +79,7 @@ module ActiveRecord
 
       ##
       # :singleton-method:
-      # Customizable data column name.  Defaults to 'data'.
+      # Customizable data column name. Defaults to 'data'.
       cattr_accessor :data_column_name
       self.data_column_name = 'data'
 
@@ -161,12 +161,12 @@ module ActiveRecord
     end
 
     # A barebones session store which duck-types with the default session
-    # store but bypasses Active Record and issues SQL directly.  This is
+    # store but bypasses Active Record and issues SQL directly. This is
     # an example session model class meant as a basis for your own classes.
     #
     # The database connection, table name, and session id and data columns
-    # are configurable class attributes.  Marshaling and unmarshaling
-    # are implemented as class methods that you may override.  By default,
+    # are configurable class attributes. Marshaling and unmarshaling
+    # are implemented as class methods that you may override. By default,
     # marshaling data is
     #
     #   ActiveSupport::Base64.encode64(Marshal.dump(data))
@@ -176,7 +176,7 @@ module ActiveRecord
     #   Marshal.load(ActiveSupport::Base64.decode64(data))
     #
     # This marshaling behavior is intended to store the widest range of
-    # binary session data in a +text+ column.  For higher performance,
+    # binary session data in a +text+ column. For higher performance,
     # store in a +blob+ column instead and forgo the Base64 encoding.
     class SqlBypass
       extend ClassMethods
@@ -286,7 +286,7 @@ module ActiveRecord
       end
     end
 
-    # The class used for session storage.  Defaults to
+    # The class used for session storage. Defaults to
     # ActiveRecord::SessionStore::Session
     cattr_accessor :session_class
     self.session_class = Session
diff --git a/activerecord/lib/active_record/test_case.rb b/activerecord/lib/active_record/test_case.rb
index 0d47eb3338..c61428e104 100644
--- a/activerecord/lib/active_record/test_case.rb
+++ b/activerecord/lib/active_record/test_case.rb
@@ -13,7 +13,7 @@ module ActiveRecord
       ActiveRecord::IdentityMap.clear
     end
 
-    # Backport skip to Ruby 1.8.  test/unit doesn't support it, so just
+    # Backport skip to Ruby 1.8. test/unit doesn't support it, so just
     # make it a noop.
     unless instance_methods.map(&:to_s).include?("skip")
       def skip(message)
diff --git a/activerecord/lib/active_record/validations.rb b/activerecord/lib/active_record/validations.rb
index 59b6876135..4b075183c3 100644
--- a/activerecord/lib/active_record/validations.rb
+++ b/activerecord/lib/active_record/validations.rb
@@ -1,7 +1,7 @@
 module ActiveRecord
   # = Active Record RecordInvalid
   #
-  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid.  Use the
+  # Raised by <tt>save!</tt> and <tt>create!</tt> when the record is invalid. Use the
   # +record+ method to retrieve the record which did not validate.
   #
   #   begin
diff --git a/activerecord/lib/active_record/validations/associated.rb b/activerecord/lib/active_record/validations/associated.rb
index 3a783aeb00..5df85304a2 100644
--- a/activerecord/lib/active_record/validations/associated.rb
+++ b/activerecord/lib/active_record/validations/associated.rb
@@ -37,10 +37,10 @@ module ActiveRecord
       #   validation contexts by default (+nil+), other options are <tt>:create</tt>
       #   and <tt>:update</tt>.
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>). The
       #   method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_associated(*attr_names)
         validates_with AssociatedValidator, _merge_attributes(attr_names)
diff --git a/activerecord/lib/active_record/validations/uniqueness.rb b/activerecord/lib/active_record/validations/uniqueness.rb
index 4db4105389..484b1d369b 100644
--- a/activerecord/lib/active_record/validations/uniqueness.rb
+++ b/activerecord/lib/active_record/validations/uniqueness.rb
@@ -83,7 +83,7 @@ module ActiveRecord
       #     validates_uniqueness_of :user_name, :scope => :account_id
       #   end 
       #
-      # Or even multiple scope parameters.  For example, making sure that a teacher can only be on the schedule once
+      # Or even multiple scope parameters. For example, making sure that a teacher can only be on the schedule once
       # per semester for a particular class.
       #
       #   class TeacherSchedule < ActiveRecord::Base
@@ -105,7 +105,7 @@ module ActiveRecord
       #   The method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or
-      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The method, proc or string should
+      #   <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>). The method, proc or string should
       #   return or evaluate to a true or false value.
       #
       # === Concurrency and integrity