ensuring that description does not exceed 100 columns

activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -106,9 +106,10 @@ def construct_scope
                         :limit => @reflection.options[:limit] } }
         end
 
-        # Join tables with additional columns on top of the two foreign keys must be considered ambiguous unless a select
-        # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has
-        # an id column. This will then overwrite the id column of the records coming back.
+        # Join tables with additional columns on top of the two foreign keys must be considered 
+        # ambiguous unless a select clause has been explicitly defined. Otherwise you can get 
+        # broken records back, if, for example, the join column also has an id column. This will 
+        # then overwrite the id column of the records coming back.
         def finding_with_ambiguous_select?(select_clause)
           !select_clause && columns.size != 2
         end

activerecord/lib/active_record/associations/has_many_through_association.rb

@@ -24,9 +24,10 @@ def destroy(*records)
         end
       end
 
-      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
-      # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero,
-      # and you need to fetch that collection afterwards, it'll take one fewer SELECT query if you use #length.
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been 
+      # loaded and calling collection.size if it has. If it's more likely than not that the collection does 
+      # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer 
+      # SELECT query if you use #length.
       def size
         return @owner.send(:read_attribute, cached_counter_attribute_name) if has_cached_counter?
         return @target.size if loaded?

activerecord/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -14,7 +14,8 @@ module TimeZoneConversion
       module ClassMethods
         protected
           # Defined for all +datetime+ and +timestamp+ attributes when +time_zone_aware_attributes+ are enabled.
-          # This enhanced read method automatically converts the UTC time stored in the database to the time zone stored in Time.zone.
+          # This enhanced read method automatically converts the UTC time stored in the database to the time 
+          # zone stored in Time.zone.
           def define_method_attribute(attr_name)
             if create_time_zone_conversion_attribute?(attr_name, columns_hash[attr_name])
               method_body, line = <<-EOV, __LINE__ + 1

activerecord/lib/active_record/attribute_methods/write.rb

@@ -14,8 +14,8 @@ def define_method_attribute=(attr_name)
           end
       end
 
-      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings for fixnum and float
-      # columns are turned into +nil+.
+      # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+. Empty strings 
+      # for fixnum and float columns are turned into +nil+.
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
         attr_name = self.class.primary_key if attr_name == 'id'

activerecord/lib/active_record/callbacks.rb

@@ -26,8 +26,8 @@ module ActiveRecord
   # <tt>after_rollback</tt>.
   #
   # That's a total of ten callbacks, which gives you immense power to react and prepare for each state in the
-  # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, except that each
-  # <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
+  # Active Record lifecycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar, 
+  # except that each <tt>_on_create</tt> callback is replaced by the corresponding <tt>_on_update</tt> callback.
   #
   # Examples:
   #   class CreditCard < ActiveRecord::Base
@@ -55,9 +55,9 @@ module ActiveRecord
   #
   # == Inheritable callback queues
   #
-  # Besides the overwritable callback methods, it's also possible to register callbacks through the use of the callback macros.
-  # Their main advantage is that the macros add behavior into a callback queue that is kept intact down through an inheritance
-  # hierarchy. Example:
+  # Besides the overwritable callback methods, it's also possible to register callbacks through the 
+  # use of the callback macros. Their main advantage is that the macros add behavior into a callback 
+  # queue that is kept intact down through an inheritance hierarchy.
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy :destroy_author
@@ -67,9 +67,9 @@ module ActiveRecord
   #     before_destroy :destroy_readers
   #   end
   #
-  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is run, both +destroy_author+ and
-  # +destroy_readers+ are called. Contrast this to the situation where we've implemented the save behavior through overwriteable
-  # methods:
+  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is 
+  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the situation where 
+  # we've implemented the save behavior through overwriteable methods:
   #
   #   class Topic < ActiveRecord::Base
   #     def before_destroy() destroy_author end
@@ -79,20 +79,21 @@ module ActiveRecord
   #     def before_destroy() destroy_readers end
   #   end
   #
-  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. So, use the callback macros when
-  # you want to ensure that a certain callback is called for the entire hierarchy, and use the regular overwriteable methods
-  # when you want to leave it up to each descendant to decide whether they want to call +super+ and trigger the inherited callbacks.
+  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+. 
+  # So, use the callback macros when you want to ensure that a certain callback is called for the entire 
+  # hierarchy, and use the regular overwriteable methods when you want to leave it up to each descendant 
+  # to decide whether they want to call +super+ and trigger the inherited callbacks.
   #
-  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the callbacks before specifying the
-  # associations. Otherwise, you might trigger the loading of a child before the parent has registered the callbacks and they won't
-  # be inherited.
+  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the 
+  # callbacks before specifying the associations. Otherwise, you might trigger the loading of a 
+  # child before the parent has registered the callbacks and they won't be inherited.
   #
   # == Types of callbacks
   #
   # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
-  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects are the
-  # recommended approaches, inline methods using a proc are sometimes appropriate (such as for creating mix-ins), and inline
-  # eval methods are deprecated.
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects 
+  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for 
+  # creating mix-ins), and inline eval methods are deprecated.
   #
   # The method reference callbacks work by specifying a protected or private method available in the object, like this:
   #
@@ -169,15 +170,15 @@ module ActiveRecord
   #       end
   #   end
   #
-  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also pass a "method string",
-  # which will then be evaluated within the binding of the callback. Example:
+  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also 
+  # pass a "method string", which will then be evaluated within the binding of the callback. Example:
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
   #   end
   #
-  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback is triggered. Also note that these
-  # inline callbacks can be stacked just like the regular ones:
+  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback 
+  # is triggered. Also note that these inline callbacks can be stacked just like the regular ones:
   #
   #   class Topic < ActiveRecord::Base
   #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
@@ -186,22 +187,24 @@ module ActiveRecord
   #
   # == The +after_find+ and +after_initialize+ exceptions
   #
-  # Because +after_find+ and +after_initialize+ are called for each object found and instantiated by a finder, such as <tt>Base.find(:all)</tt>, we've had
-  # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, +after_find+ and
-  # +after_initialize+ will only be run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
+  # Because +after_find+ and +after_initialize+ are called for each object found and instantiated by a finder, 
+  # such as <tt>Base.find(:all)</tt>, we've had to implement a simple performance constraint (50% more speed 
+  # on a simple test case). Unlike all the other callbacks, +after_find+ and +after_initialize+ will only be 
+  # run if an explicit implementation is defined (<tt>def after_find</tt>). In that case, all of the
   # callback types will be called.
   #
   # == <tt>before_validation*</tt> returning statements
   #
-  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be aborted and <tt>Base#save</tt> will return +false+.
-  # If Base#save! is called it will raise a ActiveRecord::RecordInvalid exception.
-  # Nothing will be appended to the errors object.
+  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be 
+  # aborted and <tt>Base#save</tt> will return +false+. If Base#save! is called it will raise a 
+  # ActiveRecord::RecordInvalid exception. Nothing will be appended to the errors object.
   #
   # == Canceling callbacks
   #
-  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are cancelled. If an <tt>after_*</tt> callback returns
-  # +false+, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks
-  # defined as methods on the model, which are called last.
+  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are 
+  # cancelled. If an <tt>after_*</tt> callback returns +false+, all the later callbacks are cancelled. 
+  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as 
+  # methods on the model, which are called last.
   #
   # == Transactions
   #
@@ -217,7 +220,8 @@ module ActiveRecord
   #
   # == Debugging callbacks
   #
-  # To list the methods and procs registered with a particular callback, append <tt>_callback_chain</tt> to the callback name that you wish to list and send that to your class from the Rails console:
+  # To list the methods and procs registered with a particular callback, append <tt>_callback_chain</tt> to 
+  # the callback name that you wish to list and send that to your class from the Rails console:
   #
   #   >> Topic.after_save_callback_chain
   #   => [#<ActiveSupport::Callbacks::Callback:0x3f6a448

activerecord/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -23,7 +23,8 @@ module Format
       #
       # +name+ is the column's name, such as <tt>supplier_id</tt> in <tt>supplier_id int(11)</tt>.
       # +default+ is the type-casted default value, such as +new+ in <tt>sales_stage varchar(20) default 'new'</tt>.
-      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in <tt>company_name varchar(60)</tt>.
+      # +sql_type+ is used to extract the column's length, if necessary. For example +60+ in 
+      # <tt>company_name varchar(60)</tt>.
       # It will be mapped to one of the standard Rails SQL types in the <tt>type</tt> attribute.
       # +null+ determines if this column allows +NULL+ values.
       def initialize(name, default, sql_type = nil, null = true)
@@ -359,7 +360,8 @@ def [](name)
       #
       # Available options are (none of these exists by default):
       # * <tt>:limit</tt> -
-      #   Requests a maximum column length. This is number of characters for <tt>:string</tt> and <tt>:text</tt> columns and number of bytes for :binary and :integer columns.
+      #   Requests a maximum column length. This is number of characters for <tt>:string</tt> and 
+      #   <tt>:text</tt> columns and number of bytes for :binary and :integer columns.
       # * <tt>:default</tt> -
       #   The column's default value. Use nil for NULL.
       # * <tt>:null</tt> -
@@ -462,8 +464,8 @@ def [](name)
       # TableDefinition#timestamps that'll add created_at and +updated_at+ as datetimes.
       #
       # TableDefinition#references will add an appropriately-named _id column, plus a corresponding _type
-      # column if the <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of options, these will be
-      # used when creating the <tt>_type</tt> column. So what can be written like this:
+      # column if the <tt>:polymorphic</tt> option is supplied. If <tt>:polymorphic</tt> is a hash of 
+      # options, these will be used when creating the <tt>_type</tt> column. So what can be written like this:
       #
       #   create_table :taggings do |t|
       #     t.integer :tag_id, :tagger_id, :taggable_id

activerecord/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -278,7 +278,8 @@ def select_rows(sql, name = nil)
         rows
       end
 
-      # Executes a SQL query and returns a MySQL::Result object. Note that you have to free the Result object after you're done using it.
+      # Executes a SQL query and returns a MySQL::Result object. Note that you have to free 
+      # the Result object after you're done using it.
       def execute(sql, name = nil) #:nodoc:
         if name == :skip_logging
           @connection.query(sql)

activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -183,10 +183,14 @@ module ConnectionAdapters
     # * <tt>:username</tt> - Defaults to nothing.
     # * <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.
-    # * <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 <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
-    # * <tt>:allow_concurrency</tt> - If true, use async query methods so Ruby threads don't deadlock; otherwise, use blocking query methods.
+    # * <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.
+    # * <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 
+    #   <tt>SET client_min_messages TO <min_messages></tt> call on the connection.
+    # * <tt>:allow_concurrency</tt> - If true, use async query methods so Ruby threads don't deadlock; 
+    #   otherwise, use blocking query methods.
     class PostgreSQLAdapter < AbstractAdapter
       ADAPTER_NAME = 'PostgreSQL'.freeze
 

activerecord/lib/active_record/connection_adapters/sqlite_adapter.rb

@@ -29,8 +29,8 @@ def binary_to_string(value)
       end
     end
 
-    # The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby drivers (available both as gems and
-    # from http://rubyforge.org/projects/sqlite-ruby/).
+    # The SQLite adapter works with both the 2.x and 3.x series of SQLite with the sqlite-ruby 
+    # drivers (available both as gems and from http://rubyforge.org/projects/sqlite-ruby/).
     #
     # Options:
     #

activerecord/lib/active_record/errors.rb

@@ -30,7 +30,8 @@ class AssociationTypeMismatch < ActiveRecordError
   class SerializationTypeMismatch < ActiveRecordError
   end
 
-  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt> misses adapter field).
+  # Raised when adapter not specified on connection (or configuration file <tt>config/database.yml</tt> 
+  # misses adapter field).
   class AdapterNotSpecified < ActiveRecordError
   end
 
@@ -38,7 +39,8 @@ class AdapterNotSpecified < ActiveRecordError
   class AdapterNotFound < ActiveRecordError
   end
 
-  # Raised when connection to the database could not been established (for example when <tt>connection=</tt> is given a nil object).
+  # Raised when connection to the database could not been established (for example when <tt>connection=</tt> 
+  # is given a nil object).
   class ConnectionNotEstablished < ActiveRecordError
   end
 
@@ -51,7 +53,8 @@ class RecordNotFound < ActiveRecordError
   class RecordNotSaved < ActiveRecordError
   end
 
-  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for MySQL when Ruby driver used is too old).
+  # Raised when SQL statement cannot be executed by the database (for example, it's often the case for 
+  # MySQL when Ruby driver used is too old).
   class StatementInvalid < ActiveRecordError
   end
 
@@ -78,7 +81,8 @@ class RecordNotUnique < WrappedDatabaseException
   class InvalidForeignKey < WrappedDatabaseException
   end
 
-  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example, when using +find+ method)
+  # Raised when number of bind variables in statement given to <tt>:condition</tt> key (for example, 
+  # when using +find+ method)
   # does not match number of expected variables.
   #
   # For example, in
@@ -165,4 +169,4 @@ def initialize(errors)
       @errors = errors
     end
   end
-end
+end
\ No newline at end of file

activerecord/lib/active_record/fixtures.rb

@@ -39,9 +39,10 @@ class FixtureClassNotFound < StandardError #:nodoc:
 # This type of fixture is in YAML format and the preferred default. YAML is a file format which describes data structures
 # in a non-verbose, human-readable format. It ships with Ruby 1.8.1+.
 #
-# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed in the directory appointed
-# by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <tt><your-rails-app>/test/fixtures/</tt>). The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
+# Unlike single-file fixtures, YAML fixtures are stored in a single file per model, which are placed 
+# in the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is 
+# automatically configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/</tt>). 
+# The fixture file ends with the <tt>.yml</tt> file extension (Rails example:
 # <tt><your-rails-app>/test/fixtures/web_sites.yml</tt>). The format of a YAML fixture file looks like this:
 #
 #   rubyonrails:
@@ -58,7 +59,8 @@ class FixtureClassNotFound < StandardError #:nodoc:
 # 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
+# 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:
 #
@@ -79,7 +81,8 @@ class FixtureClassNotFound < StandardError #:nodoc:
 # (Rails example: <tt><your-rails-app>/test/fixtures/web_sites.csv</tt>).
 #
 # The format of this type of fixture file is much more compact than the others, but also a little harder to read by us
-# humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the file is then comprised
+# humans.  The first line of the CSV file is a comma-separated list of field names.  The rest of the 
+# file is then comprised
 # of the actual data (1 per line).  Here's an example:
 #
 #   id, name, url
@@ -99,15 +102,16 @@ class FixtureClassNotFound < StandardError #:nodoc:
 #
 # == Single-file fixtures
 #
-# This type of fixture was the original format for Active Record that has since been deprecated in favor of the YAML and CSV formats.
-# Fixtures for this format are created by placing text files in a sub-directory (with the name of the model) to the directory
-# appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically configured for Rails, so you can just
-# put your files in <tt><your-rails-app>/test/fixtures/<your-model-name>/</tt> --
+# This type of fixture was the original format for Active Record that has since been deprecated in 
+# favor of the YAML and CSV formats.
+# Fixtures for this format are created by placing text files in a sub-directory (with the name of the model) 
+# to the directory appointed by <tt>ActiveSupport::TestCase.fixture_path=(path)</tt> (this is automatically 
+# configured for Rails, so you can just put your files in <tt><your-rails-app>/test/fixtures/<your-model-name>/</tt> --
 # like <tt><your-rails-app>/test/fixtures/web_sites/</tt> for the WebSite model).
 #
 # Each text file placed in this directory represents a "record".  Usually these types of fixtures are named without
-# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.  Here's what the
-# above example might look like:
+# extensions, but if you are on a Windows machine, you might consider adding <tt>.txt</tt> as the extension.  
+# Here's what the above example might look like:
 #
 #   web_sites/google
 #   web_sites/yahoo.txt
@@ -133,7 +137,8 @@ class FixtureClassNotFound < StandardError #:nodoc:
 #     end
 #   end
 #
-# By default, the <tt>test_helper module</tt> will load all of your fixtures into your test database, so this test will succeed.
+# By default, the <tt>test_helper module</tt> will load all of your fixtures into your test database, 
+# so this test will succeed.
 # The testing environment will automatically load the all fixtures into the database before each test.
 # To ensure consistent data, the environment deletes the fixtures before running the load.
 #
@@ -182,13 +187,15 @@ class FixtureClassNotFound < StandardError #:nodoc:
 # This will create 1000 very simple YAML fixtures.
 #
 # Using ERb, you can also inject dynamic values into your fixtures with inserts like <tt><%= Date.today.strftime("%Y-%m-%d") %></tt>.
-# This is however a feature to be used with some caution. The point of fixtures are that they're stable units of predictable
-# sample data. If you feel that you need to inject dynamic values, then perhaps you should reexamine whether your application
-# is properly testable. Hence, dynamic values in fixtures are to be considered a code smell.
+# This is however a feature to be used with some caution. The point of fixtures are that they're 
+# stable units of predictable sample data. If you feel that you need to inject dynamic values, then 
+# perhaps you should reexamine whether your application is properly testable. Hence, dynamic values 
+# in fixtures are to be considered a code smell.
 #
 # = Transactional fixtures
 #
-# TestCases can use begin+rollback to isolate their changes to the database instead of having to delete+insert for every test case.
+# TestCases can use begin+rollback to isolate their changes to the database instead of having to 
+# delete+insert for every test case.
 #
 #   class FooTest < ActiveSupport::TestCase
 #     self.use_transactional_fixtures = true
@@ -205,15 +212,18 @@ class FixtureClassNotFound < StandardError #:nodoc:
 #   end
 #
 # If you preload your test database with all fixture data (probably in the Rakefile task) and use transactional fixtures,
-# then you may omit all fixtures declarations in your test cases since all the data's already there and every case rolls back its changes.
+# then you may omit all fixtures declarations in your test cases since all the data's already there 
+# and every case rolls back its changes.
 #
 # In order to use instantiated fixtures with preloaded data, set +self.pre_loaded_fixtures+ to true. This will provide
-# access to fixture data for every table that has been loaded through fixtures (depending on the value of +use_instantiated_fixtures+)
+# access to fixture data for every table that has been loaded through fixtures (depending on the 
+# value of +use_instantiated_fixtures+)
 #
 # When *not* to use transactional fixtures:
 #
-# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until all parent transactions commit,
-#    particularly, the fixtures transaction which is begun in setup and rolled back in teardown. Thus, you won't be able to verify
+# 1. You're testing whether a transaction works correctly. Nested transactions don't commit until 
+#    all parent transactions commit, particularly, the fixtures transaction which is begun in setup 
+#    and rolled back in teardown. Thus, you won't be able to verify
 #    the results of your transaction until Active Record supports nested transactions or savepoints (in progress).
 # 2. Your database does not support transactions. Every Active Record database supports transactions except MySQL MyISAM.
 #    Use InnoDB, MaxDB, or NDB instead.

activerecord/lib/active_record/named_scope.rb

@@ -48,18 +48,21 @@ def scopes
       # The above calls to <tt>scope</tt> define class methods Shirt.red and Shirt.dry_clean_only. Shirt.red,
       # in effect, represents the query <tt>Shirt.where(:color => 'red')</tt>.
       #
-      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it resembles the association object
-      # constructed by a <tt>has_many</tt> declaration. For instance, you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>,
-      # <tt>Shirt.red.where(:size => 'small')</tt>. Also, just as with the association objects, named \scopes act like an Array,
-      # implementing Enumerable; <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
+      # Unlike <tt>Shirt.find(...)</tt>, however, the object returned by Shirt.red is not an Array; it 
+      # resembles the association object constructed by a <tt>has_many</tt> declaration. For instance, 
+      # you can invoke <tt>Shirt.red.first</tt>, <tt>Shirt.red.count</tt>, <tt>Shirt.red.where(:size => 'small')</tt>. 
+      # Also, just as with the association objects, named \scopes act like an Array, implementing Enumerable; 
+      # <tt>Shirt.red.each(&block)</tt>, <tt>Shirt.red.first</tt>, and <tt>Shirt.red.inject(memo, &block)</tt>
       # all behave as if Shirt.red really was an Array.
       #
-      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce all shirts that are both red and dry clean only.
-      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> returns the number of garments
-      # for which these criteria obtain. Similarly with <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
+      # These named \scopes are composable. For instance, <tt>Shirt.red.dry_clean_only</tt> will produce 
+      # all shirts that are both red and dry clean only.
+      # Nested finds and calculations also work with these compositions: <tt>Shirt.red.dry_clean_only.count</tt> 
+      # returns the number of garments for which these criteria obtain. Similarly with 
+      # <tt>Shirt.red.dry_clean_only.average(:thread_count)</tt>.
       #
-      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which the \scopes were defined. But they are also available to
-      # <tt>has_many</tt> associations. If,
+      # All \scopes are available as class methods on the ActiveRecord::Base descendant upon which 
+      # the \scopes were defined. But they are also available to <tt>has_many</tt> associations. If,
       #
       #   class Person < ActiveRecord::Base
       #     has_many :shirts

activerecord/lib/active_record/observer.rb

@@ -67,8 +67,8 @@ module ActiveRecord
   #
   # == Configuration
   #
-  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration setting in your
-  # <tt>config/application.rb</tt> file.
+  # In order to activate an observer, list it in the <tt>config.active_record.observers</tt> configuration 
+  # setting in your <tt>config/application.rb</tt> file.
   #
   #   config.active_record.observers = :comment_observer, :signup_observer
   #

activerecord/lib/active_record/persistence.rb

@@ -91,8 +91,8 @@ def destroy
     # like render <tt>:partial => @client.becomes(Company)</tt> to render that
     # instance using the companies/company partial instead of clients/client.
     #
-    # Note: The new instance will share a link to the same attributes as the original class. So any change to the attributes in either
-    # instance will affect the other.
+    # Note: The new instance will share a link to the same attributes as the original class. 
+    # So any change to the attributes in either instance will affect the other.
     def becomes(klass)
       became = klass.new
       became.instance_variable_set("@attributes", @attributes)

activerecord/lib/active_record/relation/calculations.rb

@@ -5,26 +5,33 @@ module Calculations
     # Count operates using three different approaches.
     #
     # * Count all: By not passing any parameters to count, it will return a count of all the rows for the model.
-    # * Count using column: By passing a column name to count, it will return a count of all the rows for the model with supplied column present
+    # * Count using column: By passing a column name to count, it will return a count of all the 
+    #   rows for the model with supplied column present
     # * Count using options will find the row count matched by the options used.
     #
     # The third approach, count using options, accepts an option hash as the only parameter. The options are:
     #
-    # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. See conditions in the intro to ActiveRecord::Base.
+    # * <tt>:conditions</tt>: An SQL fragment like "administrator = 1" or [ "user_name = ?", username ]. 
+    #   See conditions in the intro to ActiveRecord::Base.
     # * <tt>:joins</tt>: Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed)
-    #   or named associations in the same form used for the <tt>:include</tt> option, which will perform an INNER JOIN on the associated table(s).
-    #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    #   or named associations in the same form used for the <tt>:include</tt> option, which will 
+    #   perform an INNER JOIN on the associated table(s).
+    #   If the value is a string, then the records will be returned read-only since they will have 
+    #   attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
-    # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. The symbols named refer
-    #   to already defined associations. When using named associations, count returns the number of DISTINCT items for the model you're counting.
+    # * <tt>:include</tt>: Named associations that should be loaded alongside using LEFT OUTER JOINs. 
+    #   The symbols named refer to already defined associations. When using named associations, count 
+    #   returns the number of DISTINCT items for the model you're counting.
     #   See eager loading under Associations.
     # * <tt>:order</tt>: An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt>: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, want to do a join but not
+    # * <tt>:select</tt>: By default, this is * as in SELECT * FROM, but can be changed if you, for example, 
+    #   want to do a join but not
     #   include the joined columns.
-    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
-    #   of a database view).
+    # * <tt>:distinct</tt>: Set this to true to make this a distinct calculation, such as 
+    #   SELECT COUNT(DISTINCT posts.id) ...
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an 
+    #   alternate table name (or even the name of a database view).
     #
     # Examples for counting all:
     #   Person.count         # returns the total count of all people
@@ -34,12 +41,19 @@ module Calculations
     #
     # Examples for count with options:
     #   Person.count(:conditions => "age > 26")
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
-    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :joins => "LEFT JOIN jobs on jobs.person_id = person.id") # finds the number of rows matching the conditions and joins.
+    #
+    #   # because of the named association, it finds the DISTINCT count using LEFT OUTER JOIN.
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", :include => :job) 
+    #
+    #   # finds the number of rows matching the conditions and joins.
+    #   Person.count(:conditions => "age > 26 AND job.salary > 60000", 
+    #                :joins => "LEFT JOIN jobs on jobs.person_id = person.id") 
+    #
     #   Person.count('id', :conditions => "age > 26") # Performs a COUNT(id)
     #   Person.count(:all, :conditions => "age > 26") # Performs a COUNT(*) (:all is an alias for '*')
     #
-    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  Use Person.count instead.
+    # Note: <tt>Person.count(:all)</tt> will not work because it will use <tt>:all</tt> as the condition.  
+    # Use Person.count instead.
     def count(column_name = nil, options = {})
       column_name, options = nil, column_name if column_name.is_a?(Hash)
       calculate(:count, column_name, options)
@@ -80,13 +94,15 @@ def sum(column_name, options = {})
       calculate(:sum, column_name, options)
     end
 
-    # 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.
+    # 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.
     #
     # There are two basic forms of output:
-    #   * 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.
+    #   * 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.
     #
     #       values = Person.maximum(:age, :group => 'last_name')
     #       puts values["Drake"]
@@ -102,21 +118,30 @@ def sum(column_name, options = {})
     #       end
     #
     # 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, 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).
-    #   The records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    # * <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, 
+    #   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).
+    #   The records will be returned read-only since they will have attributes that do not correspond to the 
+    #   table's columns.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name" (really only used with GROUP BY calculations).
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause.
-    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not
-    #   include the joined columns.
-    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as SELECT COUNT(DISTINCT posts.id) ...
+    # * <tt>:select</tt> - By default, this is * as in SELECT * FROM, but can be changed if you for example 
+    #   want to do a join, but not include the joined columns.
+    # * <tt>:distinct</tt> - Set this to true to make this a distinct calculation, such as 
+    #   SELECT COUNT(DISTINCT posts.id) ...
     #
     # Examples:
     #   Person.calculate(:count, :all) # The same as Person.count
     #   Person.average(:age) # SELECT AVG(age) FROM people...
-    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for everyone with a last name other than 'Drake'
-    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) # Selects the minimum age for any family without any minors
+    #   Person.minimum(:age, :conditions => ['last_name != ?', 'Drake']) # Selects the minimum age for 
+    #                                                                    # everyone with a last name other than 'Drake'
+    #
+    #   # Selects the minimum age for any family without any minors
+    #   Person.minimum(:age, :having => 'min(age) > 17', :group => :last_name) 
+    #
     #   Person.sum("2 * age")
     def calculate(operation, column_name, options = {})
       if options.except(:distinct).present?

activerecord/lib/active_record/relation/finder_methods.rb

@@ -21,23 +21,28 @@ module FinderMethods
     #
     # ==== Parameters
     #
-    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
+    # * <tt>:conditions</tt> - An SQL fragment like "administrator = 1", <tt>[ "user_name = ?", username ]</tt>, 
+    #   or <tt>["user_name = :user_name", { :user_name => user_name }]</tt>. See conditions in the intro.
     # * <tt>:order</tt> - An SQL fragment like "created_at DESC, name".
     # * <tt>:group</tt> - An attribute name by which the result should be grouped. Uses the <tt>GROUP BY</tt> SQL-clause.
-    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
+    # * <tt>:having</tt> - Combined with +:group+ this can be used to filter the records that a 
+    #   <tt>GROUP BY</tt> returns. Uses the <tt>HAVING</tt> SQL-clause.
     # * <tt>:limit</tt> - An integer determining the limit on the number of rows that should be returned.
-    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5, it would skip rows 0 through 4.
+    # * <tt>:offset</tt> - An integer determining the offset from where the rows should be fetched. So at 5, 
+    #   it would skip rows 0 through 4.
     # * <tt>:joins</tt> - Either an SQL fragment for additional joins like "LEFT JOIN comments ON comments.post_id = id" (rarely needed),
-    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an <tt>INNER JOIN</tt> on the associated table(s),
+    #   named associations in the same form used for the <tt>:include</tt> option, which will perform an 
+    #   <tt>INNER JOIN</tt> on the associated table(s),
     #   or an array containing a mixture of both strings and named associations.
-    #   If the value is a string, then the records will be returned read-only since they will have attributes that do not correspond to the table's columns.
+    #   If the value is a string, then the records will be returned read-only since they will 
+    #   have attributes that do not correspond to the table's columns.
     #   Pass <tt>:readonly => false</tt> to override.
     # * <tt>:include</tt> - Names associations that should be loaded alongside. The symbols named refer
     #   to already defined associations. See eager loading under Associations.
-    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, for example, want to do a join but not
-    #   include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
-    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed to an alternate table name (or even the name
-    #   of a database view).
+    # * <tt>:select</tt> - By default, this is "*" as in "SELECT * FROM", but can be changed if you, 
+    #   for example, want to do a join but not include the joined columns. Takes a string with the SELECT SQL fragment (e.g. "id, name").
+    # * <tt>:from</tt> - By default, this is the table name of the class, but can be changed 
+    #   to an alternate table name (or even the name of a database view).
     # * <tt>:readonly</tt> - Mark the returned records read-only so they cannot be saved or updated.
     # * <tt>:lock</tt> - An SQL fragment like "FOR UPDATE" or "LOCK IN SHARE MODE".
     #   <tt>:lock => true</tt> gives connection's default exclusive lock, usually "FOR UPDATE".

activerecord/lib/active_record/timestamp.rb

@@ -21,7 +21,8 @@ module ActiveRecord
   #
   # This feature can easily be turned off by assigning value <tt>false</tt> .
   #
-  # If your attributes are time zone aware and you desire to skip time zone conversion for certain attributes then you can do following:
+  # If your attributes are time zone aware and you desire to skip time zone conversion for certain 
+  # attributes then you can do following:
   #
   #   Topic.skip_time_zone_conversion_for_attributes = [:written_on]
   module Timestamp

activerecord/lib/active_record/validations/associated.rb

@@ -27,8 +27,9 @@ module ClassMethods
       #
       # this would specify a circular dependency and cause infinite recursion.
       #
-      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to ensure that the association
-      # is both present and guaranteed to be valid, you also need to use +validates_presence_of+.
+      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to 
+      # ensure that the association is both present and guaranteed to be valid, you also need to 
+      # use +validates_presence_of+.
       #
       # Configuration options:
       # * <tt>:message</tt> - A custom error message (default is: "is invalid")
@@ -44,4 +45,4 @@ def validates_associated(*attr_names)
       end
     end
   end
-end
+end
\ No newline at end of file

activerecord/lib/active_record/validations/uniqueness.rb

@@ -78,22 +78,25 @@ def mount_sql_and_params(klass, table_name, attribute, value) #:nodoc:
     end
 
     module ClassMethods
-      # Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user
+      # Validates whether the value of the specified attributes are unique across the system. 
+      # Useful for making sure that only one user
       # can be named "davidhh".
       #
       #   class Person < ActiveRecord::Base
       #     validates_uniqueness_of :user_name, :scope => :account_id
       #   end
       #
-      # It can also validate whether the value of the specified attributes are unique based on multiple scope parameters.  For example,
-      # making sure that a teacher can only be on the schedule once per semester for a particular class.
+      # It can also validate whether the value of the specified attributes are unique based on 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
       #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
       #   end
       #
-      # When the record is created, a check is performed to make sure that no record exists in the database with the given value for the specified
-      # attribute (that maps to a column). When the record is updated, the same check is made but disregarding the record itself.
+      # When the record is created, a check is performed to make sure that no record exists in the database 
+      # with the given value for the specified attribute (that maps to a column). When the record is updated, 
+      # the same check is made but disregarding the record itself.
       #
       # Configuration options:
       # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken").
@@ -102,11 +105,12 @@ module ClassMethods
       # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
       # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
       # * <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
-      #   method, proc or string should return or evaluate to a true or false value.
+      #   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
-      #   method, proc or string should return or evaluate to a true or false value.
+      #   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.
       #
       # === Concurrency and integrity
       #