activerecord 1.8.0 → 1.9.0

data/CHANGELOG

@@ -1,3 +1,37 @@
+*1.9.0* (22th March, 2005)
+
+* Added adapter independent limit clause as a two-element array with the first being the limit, the second being the offset #795 [Sam Stephenson]. Example:
+
+    Developer.find_all nil, 'id ASC', 5      # return the first five developers 
+    Developer.find_all nil, 'id ASC', [3, 8] # return three developers, starting from #8 and forward
+    
+  This doesn't yet work with the DB2 or MS SQL adapters. Patches to make that happen are encouraged. 
+
+* Added alias_method :to_param, :id to Base, such that Active Record objects to be used as URL parameters in Action Pack automatically #812 [Nicholas Seckar/Sam Stephenson]
+
+* Improved the performance of the OCI8 adapter for Oracle #723 [pilx/gjenkins]
+
+* Added type conversion before saving a record, so string-based values like "10.0" aren't left for the database to convert #820 [dave@cherryville.org]
+
+* Added with additional settings for working with transactional fixtures and pre-loaded test databases #865 [mindel]
+
+* Fixed acts_as_list to trigger remove_from_list on destroy after the fact, not before, so a unique position can be maintained #871 [Alisdair McDiarmid]
+
+* Added the possibility of specifying fixtures in multiple calls #816 [kim@tinker.com]
+
+* Added Base.exists?(id) that'll return true if an object of the class with the given id exists #854 [stian@grytoyr.net]
+
+* Added optionally allow for nil or empty strings with validates_numericality_of #801 [Sebastian Kanthak]
+
+* Fixed problem with using slashes in validates_format_of regular expressions #801 [Sebastian Kanthak]
+
+* Fixed that SQLite3 exceptions are caught and reported properly #823 [yerejm]
+
+* Added that all types of after_find/after_initialized callbacks are triggered if the explicit implementation is present, not only the explicit implementation itself
+
+* Fixed that symbols can be used on attribute assignment, like page.emails.create(:subject => data.subject, :body => data.body)
+
+
 *1.8.0* (7th March, 2005)
 
 * Added ActiveRecord::Base.colorize_logging to control whether to use colors in logs or not (on by default)

data/lib/active_record/acts/list.rb

@@ -60,7 +60,7 @@ module ActiveRecord
             
             #{scope_condition_method}
             
-            before_destroy :remove_from_list
+            after_destroy  :remove_from_list
             before_create  :add_to_list_bottom
           EOV
         end

data/lib/active_record/base.rb

@@ -326,6 +326,13 @@ module ActiveRecord #:nodoc:
         end
       end
 
+      # Returns true if the given +id+ represents the primary key of a record in the database, false otherwise.
+      # Example:
+      #   Person.exists?(5)
+      def exists?(id)
+        !find_first("#{primary_key} = #{sanitize(id)}").nil?
+      end
+
       # This method is deprecated in favor of find with the :conditions option.
       # Works like find, but the record matching +id+ must also meet the +conditions+.
       # +RecordNotFound+ is raised if no record can be found matching the +id+ or meeting the condition.
@@ -339,16 +346,18 @@ module ActiveRecord #:nodoc:
       # table in the database. The +conditions+ can be used to narrow the selection of objects (WHERE-part),
       # such as by "color = 'red'", and arrangement of the selection can be done through +orderings+ (ORDER BY-part),
       # such as by "last_name, first_name DESC". A maximum of returned objects and their offset can be specified in 
-      # +limit+ (LIMIT...OFFSET-part). Examples:
+      # +limit+ with either just a single integer as the limit or as an array with the first element as the limit, 
+      # the second as the offset. Examples:
       #   Project.find_all "category = 'accounts'", "last_accessed DESC", 15
-      #   Project.find_all ["category = ?", category_name], "created ASC", ["? OFFSET ?", 15, 20]
+      #   Project.find_all ["category = ?", category_name], "created ASC", [15, 20]
       def find_all(conditions = nil, orderings = nil, limit = nil, joins = nil)
         sql  = "SELECT * FROM #{table_name} " 
         sql << "#{joins} " if joins
         add_conditions!(sql, conditions)
         sql << "ORDER BY #{orderings} " unless orderings.nil?
 
-        connection.add_limit!(sql, sanitize_sql(limit)) unless limit.nil?
+        limit = sanitize_sql(limit) if limit.is_a? Array and limit.first.is_a? String
+        connection.add_limit!(sql, limit) if limit
 
         find_by_sql(sql)
       end
@@ -522,7 +531,7 @@ module ActiveRecord #:nodoc:
       # "mice" table. Example:
       #
       #   class Mouse < ActiveRecord::Base
-      #      table_name "mice"
+      #      set_table_name "mice"
       #   end
       def table_name
         table_name_prefix + undecorated_table_name(class_name_of_active_record_descendant(self)) + table_name_suffix
@@ -889,6 +898,9 @@ module ActiveRecord #:nodoc:
         read_attribute(self.class.primary_key)
       end
       
+      # Enables Active Record objects to be used as URL parameters in Action Pack automatically.
+      alias_method :to_param, :id
+      
       def id_before_type_cast #:nodoc:
         read_attribute_before_type_cast(self.class.primary_key)
       end
@@ -1012,6 +1024,7 @@ module ActiveRecord #:nodoc:
       # attributes not included in that won't be allowed to be mass-assigned.
       def attributes=(attributes)
         return if attributes.nil?
+        attributes.stringify_keys!
 
         multi_parameter_attributes = []
         remove_attributes_protected_from_mass_assignment(attributes).each do |k, v| 
@@ -1233,7 +1246,7 @@ module ActiveRecord #:nodoc:
       def attributes_with_quotes(include_primary_key = true)
         columns_hash = self.class.columns_hash
 
-        attrs_quoted = @attributes.inject({}) do |attrs_quoted, pair| 
+        attrs_quoted = attributes.inject({}) do |attrs_quoted, pair| 
           attrs_quoted[pair.first] = quote(pair.last, columns_hash[pair.first]) unless !include_primary_key && pair.first == self.class.primary_key
           attrs_quoted
         end

data/lib/active_record/callbacks.rb

@@ -78,6 +78,10 @@ module ActiveRecord
   # you want to ensure that a certain callback is called for the entire hierarchy and the regular overwriteable methods when you
   # want to leave it up to each descendent 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.
+  #
   # == Types of callbacks
   #
   # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
@@ -117,7 +121,7 @@ module ActiveRecord
   #       record.credit_card_number = decrypt(record.credit_card_number)
   #     end
   #
-  #     alias_method :after_initialize, :after_save
+  #     alias_method :after_find, :after_save
   #
   #     private
   #       def encrypt(value)
@@ -151,8 +155,8 @@ module ActiveRecord
   #
   # Because after_find and after_initialize is called for each object instantiated found by a finder, such as Base.find_all, 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 can only be declared using an explicit implementation. So using the inheritable callback queue for after_find and
-  # after_initialize won't work.
+  # 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.
   #
   # == Cancelling callbacks
   #
@@ -209,8 +213,19 @@ module ActiveRecord
     module ClassMethods #:nodoc:
       def instantiate_with_callbacks(record)
         object = instantiate_without_callbacks(record)
-        object.send(:invoke_and_notify, :after_find)
-        object.send(:invoke_and_notify, :after_initialize)
+        
+        if object.send(:respond_to_without_attributes?, :after_find)
+          object.send(:callback, :after_find)
+        else
+          object.send(:invoke_and_notify, :after_find)
+        end
+
+        if object.send(:respond_to_without_attributes?, :after_initialize)
+          object.send(:callback, :after_initialize)
+        else
+          object.send(:invoke_and_notify, :after_initialize)
+        end
+
         object
       end
     end
@@ -223,7 +238,7 @@ module ActiveRecord
     def initialize_with_callbacks(attributes = nil) #:nodoc:
       initialize_without_callbacks(attributes)
       result = yield self if block_given?
-      invoke_and_notify(:after_initialize)
+      respond_to_without_attributes?(:after_initialize) ? callback(:after_initialize) : invoke_and_notify(:after_initialize)
       result
     end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -179,7 +179,7 @@ module ActiveRecord
         case type
           when :string    then value
           when :text      then value
-          when :integer   then value.to_i
+          when :integer   then value.to_i rescue value ? 1 : 0
           when :float     then value.to_f
           when :datetime  then string_to_time(value)
           when :timestamp then string_to_time(value)
@@ -353,13 +353,25 @@ module ActiveRecord
       def structure_dump() end
 
       def add_limit!(sql, limit)
+        if limit.is_a? Array
+          limit, offset = *limit
+          add_limit_with_offset!(sql, limit.to_i, offset.to_i)
+        else
+          add_limit_without_offset!(sql, limit)
+        end
+      end
+        
+      def add_limit_with_offset!(sql, limit, offset)
+        sql << " LIMIT #{limit} OFFSET #{offset}"
+      end
+      
+      def add_limit_without_offset!(sql, limit)
         sql << " LIMIT #{limit}"
       end
 
-
       def initialize_schema_information
         begin
-          execute "CREATE TABLE schema_info (version #{native_database_types[:integer]})"
+          execute "CREATE TABLE schema_info (version #{native_database_types[:integer][:name]}#{native_database_types[:integer][:limit]})"
           insert "INSERT INTO schema_info (version) VALUES(0)"
         rescue ActiveRecord::StatementInvalid
           # Schema has been intialized
@@ -377,8 +389,9 @@ module ActiveRecord
       end
 
       def add_column(table_name, column_name, type, options = {})
-        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{native_database_types[type]}"
-        add_column_sql << "(#{limit})" if options[:limit]
+        native_type = native_database_types[type]
+        add_column_sql = "ALTER TABLE #{table_name} ADD #{column_name} #{native_type[:name]}"
+        add_column_sql << "(#{options[:limit] || native_type[:limit]})" if options[:limit] || native_type[:limit]
         add_column_sql << " DEFAULT '#{options[:default]}'" if options[:default]
         execute(add_column_sql)
       end
@@ -404,7 +417,7 @@ module ActiveRecord
               log_info(sql, name, 0)
               nil
             end
-          rescue => e
+          rescue Exception => e
             log_info("#{e.message}: #{sql}", name, 0)
             raise ActiveRecord::StatementInvalid, "#{e.message}: #{sql}"
           end
@@ -452,4 +465,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/active_record/connection_adapters/db2_adapter.rb

@@ -89,7 +89,11 @@ begin
           s.gsub(/'/, "''") # ' (for ruby-mode)
         end
 
-        def add_limit!(sql, limit)
+        def add_limit_with_offset!(sql, limit, offset)
+          raise ArgumentError, 'add_limit_with_offset! not implemented'
+        end
+
+        def add_limit_without_offset!(sql, limit)
           sql << " FETCH FIRST #{limit} ROWS ONLY"
         end
 

data/lib/active_record/connection_adapters/mysql_adapter.rb

@@ -67,16 +67,16 @@ module ActiveRecord
       def native_database_types
         {
           :primary_key => "int(11) DEFAULT NULL auto_increment PRIMARY KEY",
-          :string      => "varchar(255)",
-          :text        => "text",
-          :integer     => "int(11)",
-          :float       => "float",
-          :datetime    => "datetime",
-          :timestamp   => "datetime",
-          :time        => "datetime",
-          :date        => "date",
-          :binary      => "blob",
-          :boolean     => "tinyint(1)"
+          :string      => { :name => "varchar", :limit => 255 },
+          :text        => { :name => "text" },
+          :integer     => { :name => "int", :limit => 11 },
+          :float       => { :name => "float" },
+          :datetime    => { :name => "datetime" },
+          :timestamp   => { :name => "datetime" },
+          :time        => { :name => "datetime" },
+          :date        => { :name => "date" },
+          :binary      => { :name => "blob" },
+          :boolean     => { :name => "tinyint", :limit => 1 }
         }
       end
 
@@ -172,7 +172,11 @@ module ActiveRecord
           structure += select_one("SHOW CREATE TABLE #{table.to_a.first.last}")["Create Table"] + ";\n\n"
         end
       end
- 
+      
+      def add_limit_with_offset!(sql, limit, offset)
+        sql << " LIMIT #{offset}, #{limit}"
+      end
+       
       def recreate_database(name)
         drop_database(name)
         create_database(name)

data/lib/active_record/connection_adapters/oci_adapter.rb

@@ -2,15 +2,15 @@
 # 1.  I had to redefine a method in ActiveRecord to make it possible to implement an autonumbering
 #     solution for oracle. It's implemented in a way that is intended to not break other adapters.
 # 2.  Default value support needs a patch to the OCI8 driver, to enable it to read LONG columns.
-#     LONG is deprecated, and so may never be properly added to driver.
-#     A similar patch is needed for TIMESTAMP.
-#     This is dangerous because it may break with newer versions of the driver.
+#     The driver-author has said he will add this in a future release.
+#     A similar patch is needed for TIMESTAMP. This should be replaced with the 0.2 version of the
+#     driver, which will support TIMESTAMP properly.
 # 3.  Large Object support works by an after_save callback added to the ActiveRecord. This is not
 #     a problem - you can add other (chained) after_save callbacks.
-# 4.  LIMIT and OFFSET work by scrolling through a cursor - no rownum select from select required.
-#     It does mean that large OFFSETs will have to scroll through the intervening records. To keep
-#     consistency with other adapters I've allowed the LIMIT and OFFSET clauses to be included in
-#     the sql string and later extracted them by parsing the string.
+# 4.  LIMIT and OFFSET now work using a select from select from select. This pattern enables
+#     the middle select to limit downwards as much as possible, before the outermost select
+#     limits upwards. The extra rownum column is stripped from the results.
+#     See http://asktom.oracle.com/pls/ask/f?p=4950:8:::::F4950_P8_DISPLAYID:127412348064
 #
 # Do what you want with this code, at your own peril, but if any significant portion of my code
 # remains then please acknowledge my contribution.
@@ -118,13 +118,17 @@ begin
         end
 
         def select_all(sql, name = nil)
-          offset = sql =~ /OFFSET (\d+)$/ ? $1.to_i : -1
+          offset = sql =~ /OFFSET (\d+)$/ ? $1.to_i : 0
           sql, limit = $1, $2.to_i if sql =~ /(.*)(?: LIMIT[= ](\d+))(\s*OFFSET \d+)?$/
+          if limit
+            sql = "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_ where rownum <= #{offset+limit}) where raw_rnum_ > #{offset}"
+          elsif offset > 0
+            sql = "select * from (select raw_sql_.*, rownum raw_rnum_ from (#{sql}) raw_sql_) where raw_rnum_ > #{offset}"
+          end
           cursor = log(sql, name, @connection) { @connection.exec sql }
           cols = cursor.get_col_names.map { |x| x.downcase }
           rows = []
           while row = cursor.fetch
-            next if cursor.row_count <= offset
             hash = Hash.new
             cols.each_with_index { |col, i|
               hash[col] = case row[i]
@@ -134,10 +138,9 @@ begin
                   (row[i].hour == 0 and row[i].minute == 0 and row[i].second == 0) ?
                     row[i].to_date : row[i].to_time
                 else row[i]
-                end
+                end unless col == 'raw_rnum_'
             }
             rows << hash
-            break if rows.size == limit
           end
           rows
         ensure
@@ -179,10 +182,6 @@ begin
         alias :update :execute
         alias :delete :execute
 
-        def add_limit!(sql, limit)
-          sql << "LIMIT=" << limit.to_s
-        end
-
         def begin_db_transaction()
           @connection.autocommit = false
         end

data/lib/active_record/connection_adapters/sqlserver_adapter.rb

@@ -253,19 +253,12 @@ EOL
         "[#{name}]"
       end
 
-      def add_limit!(sql, limit)
-        if sql =~ /LIMIT/i
-          limit = sql.slice!(/LIMIT.*/).gsub(/LIMIT.(.*)$/, '\1')
-        end
-        if !limit.nil?
-          limit_amount = limit.to_s.include?("OFFSET") ? get_offset_amount(limit) : Array.new([limit])
-          order_by = sql.include?("ORDER BY") ? get_order_by(sql.sub(/.*ORDER\sBY./, "")) : nil
-          if limit_amount.size == 2
-            sql.gsub!(/SELECT/i, "SELECT * FROM ( SELECT TOP #{limit_amount[0]} * FROM ( SELECT TOP #{limit_amount[1]}")<<" ) AS tmp1 ORDER BY #{order_by[1]} ) AS tmp2 ORDER BY #{order_by[0]}"
-          else
-            sql.gsub!(/SELECT/i, "SELECT TOP #{limit_amount[0]}")
-          end
-        end
+      def add_limit_with_offset!(sql, limit, offset)
+        raise ArgumentError, 'add_limit_with_offset! not implemented'
+      end
+
+      def add_limit_without_offset!(sql, limit)
+        raise ArgumentError, 'add_limit_without_offset! not implemented'
       end
 
       def recreate_database(name)

data/lib/active_record/fixtures.rb

@@ -121,6 +121,14 @@ require 'csv'
 # from a CSV fixture file would be accessible via @web_sites["web_site_1"]["name"] == "Ruby on Rails" and have the individual
 # fixtures available as instance variables @web_site_1 and @web_site_2.
 #
+# If you do not wish to use instantiated fixtures (usually for performance reasons) there are two options.
+#
+#   - to completely disable instantiated fixtures:
+#       self.use_instantiated_fixtures = false
+#
+#   - to keep the fixture instance (@web_sites) available, but do not automatically 'find' each instance:
+#       self.use_instantiated_fixtures = :no_instances 
+#
 # = Dynamic fixtures with ERb
 #
 # Some times you don't care about the content of the fixtures as much as you care about the volume. In these cases, you can
@@ -164,6 +172,9 @@ require 'csv'
 # 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.
 #
+# 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+)
+#
 # 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 
@@ -173,14 +184,25 @@ require 'csv'
 class Fixtures < Hash
   DEFAULT_FILTER_RE = /\.ya?ml$/
 
-  def self.instantiate_fixtures(object, table_name, fixtures)
+  def self.instantiate_fixtures(object, table_name, fixtures, load_instances=true)
     object.instance_variable_set "@#{table_name}", fixtures
-    fixtures.each do |name, fixture|
-      if model = fixture.find
-        object.instance_variable_set "@#{name}", model
+    if load_instances
+      fixtures.each do |name, fixture|
+        if model = fixture.find
+          object.instance_variable_set "@#{name}", model
+        end
       end
     end
   end
+  
+  def self.instantiate_all_loaded_fixtures(object, load_instances=true)
+    all_loaded_fixtures.each do |table_name, fixtures|
+      Fixtures.instantiate_fixtures(object, table_name, fixtures, load_instances)
+    end  
+  end
+  
+  cattr_accessor :all_loaded_fixtures
+  self.all_loaded_fixtures = {}
 
   def self.create_fixtures(fixtures_directory, *table_names)
     connection = block_given? ? yield : ActiveRecord::Base.connection
@@ -189,15 +211,17 @@ class Fixtures < Hash
     begin
       ActiveRecord::Base.logger.level = Logger::ERROR
 
+      fixtures_map = {}
       fixtures = table_names.flatten.map do |table_name|
-        Fixtures.new(connection, File.split(table_name.to_s).last, File.join(fixtures_directory, table_name.to_s))
-      end
-
+        fixtures_map[table_name] = Fixtures.new(connection, File.split(table_name.to_s).last, File.join(fixtures_directory, table_name.to_s))
+      end               
+      all_loaded_fixtures.merge! fixtures_map  
+      
       connection.transaction do
         fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
         fixtures.each { |fixture| fixture.insert_fixtures }
       end
-
+      
       reset_sequences(connection, table_names) if connection.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQLAdapter)
 
       return fixtures.size > 1 ? fixtures : fixtures.first
@@ -360,19 +384,21 @@ module Test #:nodoc:
       cattr_accessor :fixture_path
       class_inheritable_accessor :fixture_table_names
       class_inheritable_accessor :use_transactional_fixtures
-      class_inheritable_accessor :use_instantiated_fixtures
+      class_inheritable_accessor :use_instantiated_fixtures   # true, false, or :no_instances
+      class_inheritable_accessor :pre_loaded_fixtures
 
       self.fixture_table_names = []
       self.use_transactional_fixtures = false
       self.use_instantiated_fixtures = true
+      self.pre_loaded_fixtures = false
 
       def self.fixtures(*table_names)
-        self.fixture_table_names = table_names.flatten
+        self.fixture_table_names |= table_names.flatten
         require_fixture_classes
       end
 
-      def self.require_fixture_classes
-        fixture_table_names.each do |table_name| 
+      def self.require_fixture_classes(table_names=nil)
+        (table_names || fixture_table_names).each do |table_name| 
           begin
             require Inflector.singularize(table_name.to_s)
           rescue LoadError
@@ -382,6 +408,10 @@ module Test #:nodoc:
       end
 
       def setup_with_fixtures
+        if pre_loaded_fixtures && !use_transactional_fixtures
+          raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures' 
+        end
+
         # Load fixtures once and begin transaction.
         if use_transactional_fixtures
           load_fixtures unless @already_loaded_fixtures
@@ -438,13 +468,29 @@ module Test #:nodoc:
             @loaded_fixtures[table_name] = Fixtures.create_fixtures(fixture_path, table_name)
           end
         end
-
+        
+        # for pre_loaded_fixtures, only require the classes once. huge speed improvement
+        @@required_fixture_classes = false
+        
         def instantiate_fixtures
-          raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
-          @loaded_fixtures.each do |table_name, fixtures|
-            Fixtures.instantiate_fixtures(self, table_name, fixtures)
+          if pre_loaded_fixtures
+            raise RuntimeError, 'Load fixtures before instantiating them.' if Fixtures.all_loaded_fixtures.empty?
+            unless @@required_fixture_classes
+              self.class.require_fixture_classes Fixtures.all_loaded_fixtures.keys 
+              @@required_fixture_classes = true
+            end
+            Fixtures.instantiate_all_loaded_fixtures(self, load_instances?)
+          else 
+            raise RuntimeError, 'Load fixtures before instantiating them.' if @loaded_fixtures.nil?
+            @loaded_fixtures.each do |table_name, fixtures|
+              Fixtures.instantiate_fixtures(self, table_name, fixtures, load_instances?)
+            end
           end
         end
+        
+        def load_instances?
+          use_instantiated_fixtures != :no_instances
+        end
     end
 
   end

data/lib/active_record/migration.rb

@@ -1,8 +1,8 @@
 module ActiveRecord
-  class IrreversibleMigration < ActiveRecordError
+  class IrreversibleMigration < ActiveRecordError#:nodoc:
   end
   
-  class Migration
+  class Migration #:nodoc:
     class << self
       def up() end
       def down() end
@@ -14,7 +14,7 @@ module ActiveRecord
     end
   end
 
-  class Migrator
+  class Migrator#:nodoc:
     class << self
       def up(migrations_path, target_version = nil)
         new(:up, migrations_path, target_version).migrate

data/lib/active_record/validations.rb

@@ -270,11 +270,11 @@ module ActiveRecord
       def validates_confirmation_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:confirmation], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
 
-        for attr_name in attr_names
-          attr_accessor "#{attr_name}_confirmation"
-          class_eval(%(#{validation_method(configuration[:on])} %{errors.add('#{attr_name}', "#{configuration[:message]}") unless #{attr_name}_confirmation.nil? or #{attr_name} == #{attr_name}_confirmation}))
+        attr_accessor *(attr_names.map { |n| "#{n}_confirmation" })
+	
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
         end
       end
 
@@ -294,13 +294,13 @@ module ActiveRecord
       #
       # NOTE: The agreement is considered valid if it's set to the string "1". This makes it easy to relate it to an HTML checkbox.
       def validates_acceptance_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save }
+        configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
 
-        for attr_name in attr_names
-          attr_accessor(attr_name)
-          class_eval(%(#{validation_method(configuration[:on])} %{errors.add('#{attr_name}', "#{configuration[:message]}") unless #{attr_name}.nil? or #{attr_name} == "1"}))
+        attr_accessor *attr_names
+	
+        validates_each(attr_names,configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless value == "1"	  
         end
       end
 
@@ -312,10 +312,13 @@ module ActiveRecord
       def validates_presence_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:empty], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
 
-        for attr_name in attr_names
-          class_eval(%(#{validation_method(configuration[:on])} %{errors.add_on_empty('#{attr_name}', "#{configuration[:message]}")}))
+        # can't use validates_each here, because it cannot cope with non-existant attributes,
+        # while errors.add_on_empty can	
+        attr_names.each do |attr_name|
+          send(validation_method(configuration[:on])) do |record|
+            record.errors.add_on_empty(attr_name,configuration[:message])
+          end
         end
       end
 
@@ -414,13 +417,14 @@ module ActiveRecord
       def validates_uniqueness_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken] }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
 
-        for attr_name in attr_names
-          if scope = configuration[:scope]
-            class_eval(%(validate %{errors.add('#{attr_name}', "#{configuration[:message]}") if self.class.find_first(new_record? ? ['#{attr_name} = ? AND #{scope} = ?', #{attr_name}, #{scope}] : ["#{attr_name} = ? AND \\\#{self.class.primary_key} <> ? AND #{scope} = ?", #{attr_name}, id, #{scope}])}))
-          else
-            class_eval(%(validate %{errors.add('#{attr_name}', "#{configuration[:message]}") if self.class.find_first(new_record? ? ['#{attr_name} = ?', #{attr_name}] : ["#{attr_name} = ? AND \\\#{self.class.primary_key} <> ?", #{attr_name}, id])}))
+        if scope = configuration[:scope]
+          validates_each(attr_names,configuration) do |record, attr_name, value|
+            record.errors.add(attr_name, configuration[:message]) if record.class.find_first(record.new_record? ? ["#{attr_name} = ? AND #{scope} = ?", record.send(attr_name), record.send(scope)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ? AND #{scope} = ?", record.send(attr_name), record.send(:id), record.send(scope)])
+          end
+        else
+          validates_each(attr_names,configuration) do |record, attr_name, value|
+            record.errors.add(attr_name, configuration[:message]) if record.class.find_first(record.new_record? ? ["#{attr_name} = ?", record.send(attr_name)] : ["#{attr_name} = ? AND #{record.class.primary_key} <> ?", record.send(attr_name), record.send(:id) ] )
           end
         end
       end
@@ -441,12 +445,11 @@ module ActiveRecord
       def validates_format_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save, :with => nil }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
 
         raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash") unless configuration[:with].is_a?(Regexp)
 
-        for attr_name in attr_names 
-          class_eval(%(#{validation_method(configuration[:on])} %{errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name} and #{attr_name}.to_s.match(/#{Regexp.quote(configuration[:with].source)}/)}))
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless value.to_s =~ configuration[:with]
         end
       end
 
@@ -464,19 +467,13 @@ module ActiveRecord
       def validates_inclusion_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
-
+ 
         enum = configuration[:in] || configuration[:within]
-        allow_nil = configuration[:allow_nil]
-
+ 
         raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash") unless enum.respond_to?("include?")
 
-        for attr_name in attr_names
-          if allow_nil
-            class_eval(%(#{validation_method(configuration[:on])} %{errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name}.nil? or (#{enum.inspect}).include?(#{attr_name}) }))
-          else
-            class_eval(%(#{validation_method(configuration[:on])} %{errors.add("#{attr_name}", "#{configuration[:message]}") unless (#{enum.inspect}).include?(#{attr_name}) }))
-          end
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless enum.include?(value)
         end
       end
 
@@ -504,13 +501,10 @@ module ActiveRecord
       def validates_associated(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
-        configuration[:message].gsub!(/\"/, '\\\\\"')
-        
-        for attr_name in attr_names
-          class_eval(%(#{validation_method(configuration[:on])} %{
-            errors.add("#{attr_name}", "#{configuration[:message]}") unless
-              (#{attr_name}.is_a?(Array) ? #{attr_name} : [#{attr_name}]).inject(true){ |memo, record| (record.nil? or record.valid?) and memo }
-          }))
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless 
+            (value.is_a?(Array) ? value : [value]).inject(true) { |memo, r| (r.nil? or r.valid?) and memo }
         end
       end
       
@@ -526,29 +520,25 @@ module ActiveRecord
       # * <tt>message</tt> - A custom error message (default is: "is not a number")
       # * <tt>on</tt> Specifies when this validation is active (default is :save, other options :create, :update)
       # * <tt>only_integer</tt> Specifies whether the value has to be an integer, e.g. an integral value (default is false)
+      # * <tt>allow_nil</tt> Skip validation if attribute is nil (default is false). Notice that for fixnum and float columsn empty strings are converted to nil
       def validates_numericality_of(*attr_names)
         configuration = { :message => ActiveRecord::Errors.default_error_messages[:not_a_number], :on => :save,
-                           :integer => false }
+                           :only_integer => false, :allow_nil => false }
         configuration.update(attr_names.pop) if attr_names.last.is_a?(Hash)
 
-        for attr_name in attr_names
-          if configuration[:only_integer]
-            # we have to use a regexp here, because Kernel.Integer accepts nil and "0xdeadbeef", but does not
-            # accept "099" and String#to_i accepts everything. The string containing the regexp is evaluated twice
-            # so we have to escape everything properly
-            class_eval(%(#{validation_method(configuration[:on])} %{
-                errors.add("#{attr_name}", "#{configuration[:message]}") unless #{attr_name}_before_type_cast.to_s =~ /^[\\\\+\\\\-]?\\\\d+$/
-            }))          
-          else
-            class_eval(%(#{validation_method(configuration[:on])} %{
-                begin
-                  Kernel.Float(#{attr_name}_before_type_cast)
-                rescue ArgumentError, TypeError
-                  errors.add("#{attr_name}", "#{configuration[:message]}")
-                end
-            }))
+        if configuration[:only_integer]
+          validates_each(attr_names,configuration) do |record, attr_name,value|
+            record.errors.add(attr_name, configuration[:message]) unless record.send("#{attr_name}_before_type_cast").to_s =~ /^[+-]?\d+$/
           end
-        end
+        else
+          validates_each(attr_names,configuration) do |record, attr_name,value|
+            begin
+              Kernel.Float(record.send("#{attr_name}_before_type_cast").to_s)
+            rescue ArgumentError, TypeError
+              record.errors.add(attr_name, configuration[:message])
+            end
+          end
+      	end
       end
 
       private

data/rakefile

@@ -8,7 +8,7 @@ require 'rake/contrib/rubyforgepublisher'
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'activerecord'
-PKG_VERSION   = '1.8.0' + PKG_BUILD
+PKG_VERSION   = '1.9.0' + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 PKG_FILES = FileList[
@@ -117,7 +117,7 @@ spec = Gem::Specification.new do |s|
     s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
   end
   
-  s.add_dependency('activesupport', '= 1.0.1' + PKG_BUILD)
+  s.add_dependency('activesupport', '= 1.0.2' + PKG_BUILD)
 
   s.files.delete "test/fixtures/fixture_database.sqlite"
   s.files.delete "test/fixtures/fixture_database_2.sqlite"

data/test/active_schema_mysql.rb

@@ -0,0 +1,31 @@
+require 'abstract_unit'
+
+class ActiveSchemaTest < Test::Unit::TestCase
+  def setup
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.class_eval do
+      alias_method :real_execute, :execute
+      def execute(sql, name = nil) return sql end
+    end    
+  end
+  
+  def teardown
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.send(:alias_method, :execute, :real_execute)
+  end
+
+  def test_drop_table
+    assert_equal "DROP TABLE people", drop_table(:people)
+  end
+  
+  def test_add_column
+    assert_equal "ALTER TABLE people ADD last_name varchar(255)", add_column(:people, :last_name, :string)
+  end
+  
+  def test_add_column_with_limit
+    assert_equal "ALTER TABLE people ADD key varchar(32)", add_column(:people, :key, :string, :limit => 32)
+  end
+  
+  private
+    def method_missing(method_symbol, *arguments)
+      ActiveRecord::Base.connection.send(method_symbol, *arguments)
+    end
+end

data/test/callbacks_test.rb

@@ -41,14 +41,11 @@ class CallbackDeveloper < ActiveRecord::Base
     @history ||= []
   end
 
-  # after_initialize and after_find may not be declared using class methods.
-  # They are invoked only if instance methods have been defined.
+  # after_initialize and after_find are invoked only if instance methods have been defined.
   def after_initialize
-    history << [:after_initialize, :method]
   end
 
   def after_find
-    history << [:after_find, :method]
   end
 end
 
@@ -61,15 +58,24 @@ class CallbacksTest < Test::Unit::TestCase
   def test_initialize
     david = CallbackDeveloper.new
     assert_equal [
-      [ :after_initialize,            :method ]
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
     ], david.history
   end
 
   def test_find
     david = CallbackDeveloper.find(1)
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ]
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
     ], david.history
   end
 
@@ -77,7 +83,10 @@ class CallbacksTest < Test::Unit::TestCase
     david = CallbackDeveloper.new
     david.valid?
     assert_equal [
-      [ :after_initialize,            :method ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_validation,           :string ],
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],
@@ -101,8 +110,14 @@ class CallbacksTest < Test::Unit::TestCase
     david = CallbackDeveloper.find(1)
     david.valid?
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ],
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_validation,           :string ],
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],
@@ -125,7 +140,10 @@ class CallbacksTest < Test::Unit::TestCase
   def test_create
     david = CallbackDeveloper.create('name' => 'David', 'salary' => 1000000)
     assert_equal [
-      [ :after_initialize,            :method ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_validation,           :string ],
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],
@@ -165,8 +183,14 @@ class CallbacksTest < Test::Unit::TestCase
     david = CallbackDeveloper.find(1)
     david.save
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ],
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_validation,           :string ],
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],
@@ -206,8 +230,14 @@ class CallbacksTest < Test::Unit::TestCase
     david = CallbackDeveloper.find(1)
     david.destroy
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ],
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_destroy,              :string ],
       [ :before_destroy,              :proc   ],
       [ :before_destroy,              :object ],
@@ -223,8 +253,14 @@ class CallbacksTest < Test::Unit::TestCase
     david = CallbackDeveloper.find(1)
     CallbackDeveloper.delete(david.id)
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ]
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
     ], david.history
   end
 
@@ -234,8 +270,14 @@ class CallbacksTest < Test::Unit::TestCase
     CallbackDeveloper.before_validation proc { |model| model.history << [:before_validation, :should_never_get_here] }
     david.save
     assert_equal [
-      [ :after_find,                  :method ],
-      [ :after_initialize,            :method ],
+      [ :after_find,            :string ],
+      [ :after_find,            :proc   ],
+      [ :after_find,            :object ],
+      [ :after_find,            :block  ],
+      [ :after_initialize,            :string ],
+      [ :after_initialize,            :proc   ],
+      [ :after_initialize,            :object ],
+      [ :after_initialize,            :block  ],
       [ :before_validation,           :string ],
       [ :before_validation,           :proc   ],
       [ :before_validation,           :object ],

data/test/connections/native_sqlite/connection.rb

@@ -13,7 +13,7 @@ sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite"
 def make_connection(clazz, db_file, db_definitions_file)
   unless File.exist?(db_file)
     puts "SQLite database not found at #{db_file}. Rebuilding it."
-    sqlite_command = "sqlite #{db_file} 'create table a (a integer); drop table a;'"
+    sqlite_command = %Q{sqlite #{db_file} "create table a (a integer); drop table a;"}
     puts "Executing '#{sqlite_command}'"
     raise SqliteError.new("Seems that there is no sqlite executable available") unless system(sqlite_command)
     clazz.establish_connection(

data/test/connections/native_sqlite3/connection.rb

@@ -13,7 +13,7 @@ sqlite_test_db2 = "#{BASE_DIR}/fixture_database_2.sqlite3"
 def make_connection(clazz, db_file, db_definitions_file)
   unless File.exist?(db_file)
     puts "SQLite3 database not found at #{db_file}. Rebuilding it."
-    sqlite_command = "sqlite3 #{db_file} 'create table a (a integer); drop table a;'"
+    sqlite_command = %Q{sqlite3 #{db_file} "create table a (a integer); drop table a;"}
     puts "Executing '#{sqlite_command}'"
     raise SqliteError.new("Seems that there is no sqlite3 executable available") unless system(sqlite_command)
     clazz.establish_connection(

data/test/finder_test.rb

@@ -4,12 +4,19 @@ require 'fixtures/topic'
 require 'fixtures/entrant'
 
 class FinderTest < Test::Unit::TestCase
-  fixtures :companies, :topics, :entrants
+  fixtures :companies, :topics, :entrants, :developers
   
   def test_find
     assert_equal(@topics["first"]["title"], Topic.find(1).title)
   end
   
+  def test_exists
+    assert (Topic.exists?(1))
+    assert !(Topic.exists?(45))
+    assert !(Topic.exists?("foo"))
+    assert !(Topic.exists?([1,2]))
+  end
+  
   def test_find_by_array_of_one_id
     assert_kind_of(Array, Topic.find([ 1 ]))
        assert_equal(1, Topic.find([ 1 ]).length)
@@ -233,6 +240,37 @@ class FinderTest < Test::Unit::TestCase
     assert_equal "Mary", topics[0].author_name
   end
 
+  def test_find_with_bad_sql
+    assert_raises(ActiveRecord::StatementInvalid) { Topic.find_by_sql "select 1 from badtable" }
+  end
+
+  def test_find_all_with_limit
+    first_five_developers = Developer.find_all nil, 'id ASC', 5
+    assert_equal 5, first_five_developers.length
+    assert_equal 'David', first_five_developers.first.name
+    assert_equal 'fixture_5', first_five_developers.last.name
+    
+    no_developers = Developer.find_all nil, 'id ASC', 0
+    assert_equal 0, no_developers.length
+    
+    assert_equal first_five_developers, Developer.find_all(nil, 'id ASC', [5])
+    assert_equal no_developers, Developer.find_all(nil, 'id ASC', [0])
+  end
+  
+  def test_find_all_with_limit_and_offset
+    first_three_developers = Developer.find_all nil, 'id ASC', [3, 0]
+    second_three_developers = Developer.find_all nil, 'id ASC', [3, 3]
+    last_two_developers = Developer.find_all nil, 'id ASC', [3, 8]
+    
+    assert_equal 3, first_three_developers.length
+    assert_equal 3, second_three_developers.length
+    assert_equal 2, last_two_developers.length
+    
+    assert_equal 'David', first_three_developers.first.name
+    assert_equal 'fixture_4', second_three_developers.first.name
+    assert_equal 'fixture_9', last_two_developers.first.name
+  end
+
   protected
     def bind(statement, *vars)
       if vars.first.is_a?(Hash)

data/test/fixtures/db_definitions/sqlserver.sql

@@ -119,7 +119,7 @@ CREATE TABLE people (
 
 CREATE TABLE binaries (
   id int NOT NULL IDENTITY(1, 1),
-  data blob NULL,
+  data image NULL,
   PRIMARY KEY (id)
 );
 

data/test/fixtures_test.rb

@@ -113,8 +113,10 @@ class FixturesWithoutInstantiationTest < Test::Unit::TestCase
   fixtures :topics, :developers, :accounts
 
   def test_without_complete_instantiation
-    assert_nil @topics
     assert_nil @first
+    assert_nil @topics
+    assert_nil @developers
+    assert_nil @accounts
   end
 
   def test_fixtures_from_root_yml_without_instantiation
@@ -123,6 +125,19 @@ class FixturesWithoutInstantiationTest < Test::Unit::TestCase
 end
 
 
+class FixturesWithoutInstanceInstantiationTest < Test::Unit::TestCase
+  self.use_instantiated_fixtures = :no_instances
+  fixtures :topics, :developers, :accounts
+
+  def test_without_instance_instantiation
+    assert_nil @first
+    assert_not_nil @topics
+    assert_not_nil @developers
+    assert_not_nil @accounts
+  end
+end
+
+
 class TransactionalFixturesTest < Test::Unit::TestCase
   self.use_transactional_fixtures = true
   fixtures :topics
@@ -136,3 +151,23 @@ class TransactionalFixturesTest < Test::Unit::TestCase
     assert_not_nil @first
   end
 end
+
+
+class MultipleFixturesTest < Test::Unit::TestCase
+  fixtures :topics
+  fixtures :developers, :accounts
+
+  def test_fixture_table_names
+    assert_equal([:topics, :developers, :accounts], fixture_table_names)
+  end
+end
+
+
+class OverlappingFixturesTest < Test::Unit::TestCase
+  fixtures :topics, :developers
+  fixtures :developers, :accounts
+
+  def test_fixture_table_names
+    assert_equal([:topics, :developers, :accounts], fixture_table_names)
+  end
+end

data/test/validations_test.rb

@@ -606,40 +606,40 @@ class ValidationsTest < Test::Unit::TestCase
   end
 
   def test_validates_numericality_of_with_string
-    Topic.validates_numericality_of( :replies_count )
+    Topic.validates_numericality_of( :approved )
     ["not a number","42 not a number","0xdeadbeef","00-1","-+019.0","12.12.13.12",nil].each do |v|
-        t = Topic.create("title" => "numeric test", "content" => "whatever", "replies_count" => "not a number")
+        t = Topic.create("title" => "numeric test", "content" => "whatever", "approved" => "not a number")
         assert !t.valid?, "#{v} not rejected as a number"
-        assert t.errors.on(:replies_count)
+        assert t.errors.on(:approved)
     end
   end
 
   def test_validates_numericality_of
-    Topic.validates_numericality_of( :replies_count )
-    ["10", "10.0", "10.5", "-10.5", "-0.0001","0090","-090","-090.1"].each do |v|
-        t = Topic.create("title" => "numeric test", "content" => "whatever", "replies_count" => v)
+    Topic.validates_numericality_of( :approved, :allow_nil => true )
+    ["10", "10.0", "10.5", "-10.5", "-0.0001","0090","-090","-090.1",nil,""].each do |v|
+        t = Topic.create("title" => "numeric test", "content" => "whatever", "approved" => v)
         assert t.valid?, "#{v} not recognized as a number"
-        # we cannot check this as replies_count is actually an integer field
-        #assert_in_delta v.to_f, t.replies_count, 0.0000001
+        # we cannot check this as approved is actually an integer field
+        #assert_in_delta v.to_f, t.approved, 0.0000001
     end
   end
   
   def test_validates_numericality_of_int_with_string
-    Topic.validates_numericality_of( :replies_count, :only_integer => true )
+    Topic.validates_numericality_of( :approved, :only_integer => true )
     ["not a number","42 not a number","0xdeadbeef","0-1","--3","+-3","+3-1",nil].each do |v|
-        t = Topic.create("title" => "numeric test", "content" => "whatever", "replies_count" => v)
+        t = Topic.create("title" => "numeric test", "content" => "whatever", "approved" => v)
         assert !t.valid?, "#{v} not rejected as integer"
-        assert t.errors.on(:replies_count)
+        assert t.errors.on(:approved)
     end
   end
   
   def test_validates_numericality_of_int
-    Topic.validates_numericality_of( :replies_count, :only_integer => true )
-    ["42", "+42", "-42", "042", "0042", "-042", 42].each do |v|
-        t = Topic.create("title" => "numeric test", "content" => "whatever", "replies_count" => v)
+    Topic.validates_numericality_of( :approved, :only_integer => true, :allow_nil => true )
+    ["42", "+42", "-42", "042", "0042", "-042", 42, nil,""].each do |v|
+        t = Topic.create("title" => "numeric test", "content" => "whatever", "approved" => v)
         assert t.valid?, "#{v} not recognized as integer"
-        assert_equal v.to_i, t.replies_count
+        assert_equal((v.nil? or v == "")? nil : v.to_i, t.approved)
     end
   end
-  
+
 end

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.6
+rubygems_version: 0.8.8
 specification_version: 1
 name: activerecord
 version: !ruby/object:Gem::Version 
-  version: 1.8.0
-date: 2005-03-07
+  version: 1.9.0
+date: 2005-03-22
 summary: Implements the ActiveRecord pattern for ORM.
 require_paths: 
   - lib
@@ -77,6 +77,7 @@ files:
   - lib/active_record/wrappers/yaml_wrapper.rb
   - test/aaa_create_tables_test.rb
   - test/abstract_unit.rb
+  - test/active_schema_mysql.rb
   - test/aggregations_test.rb
   - test/all.sh
   - test/association_inheritance_reload.rb
@@ -226,5 +227,5 @@ dependencies:
         - 
           - "="
           - !ruby/object:Gem::Version 
-            version: 1.0.1
+            version: 1.0.2
       version: