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,15 +30,17 @@ 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
 
   # Raised when Active Record cannot find database adapter specified in <tt>config/database.yml</tt> or programmatically.
   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