From 26392c4ac57e27c63984d47c6326c13f502d5786 Mon Sep 17 00:00:00 2001
From: Jeroen van Dijk <jeroen@jeevidee.nl>
Date: Wed, 19 May 2010 15:25:46 +0100
Subject: Make ActiveModel::Errors#add_on_blank and #add_on_empty accept an
 options hash and make various Validators pass their (filtered) options.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This makes it possible to pass additional options through Validators to message generation. E.g. plugin authors want to add validates_presence_of :foo, :format => "some format".

Also, cleanup the :default vs :message options confusion in ActiveModel validation message generation.

Also, deprecate ActiveModel::Errors#add_on_blank(attributes, custom_message) in favor of ActiveModel::Errors#add_on_blank(attributes, options).

Also, refactoring of ActiveModel and ActiveRecord Validation tests. Test are a lot more DRY now. Better test coverage as well now.

The first four points were reapplied from an older patch of Sven Fuchs which didn't apply cleanly anymore and was not complete yet.

Signed-off-by: José Valim <jose.valim@gmail.com>
---
 activemodel/lib/active_model/errors.rb             |  52 ++-
 .../lib/active_model/validations/acceptance.rb     |   4 +-
 .../lib/active_model/validations/confirmation.rb   |   6 +-
 .../lib/active_model/validations/exclusion.rb      |   5 +-
 activemodel/lib/active_model/validations/format.rb |   6 +-
 .../lib/active_model/validations/inclusion.rb      |   5 +-
 activemodel/lib/active_model/validations/length.rb |   8 +-
 .../lib/active_model/validations/numericality.rb   |  13 +-
 .../lib/active_model/validations/presence.rb       |   2 +-
 .../i18n_generate_message_validation_test.rb       |  82 ++--
 .../test/cases/validations/i18n_validation_test.rb | 507 +++++++--------------
 11 files changed, 279 insertions(+), 411 deletions(-)

(limited to 'activemodel')

diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index 9efb683547..b4660f3587 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -182,25 +182,43 @@ module ActiveModel
     # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
     def add(attribute, message = nil, options = {})
       message ||= :invalid
-      message = generate_message(attribute, message, options) if message.is_a?(Symbol)
+
+      validation_conditionals = [:if, :unless, :on]
+
+      message = generate_message(attribute, message, options.except(*validation_conditionals)) if message.is_a?(Symbol)
+
       message = message.call if message.is_a?(Proc)
       self[attribute] << message
     end
 
     # Will add an error message to each of the attributes in +attributes+ that is empty.
-    def add_on_empty(attributes, custom_message = nil)
+    def add_on_empty(attributes, options = {})
+      if options && !options.is_a?(Hash)
+        options = { :message => options }
+        ActiveSupport::Deprecation.warn \
+          "ActiveModel::Errors#add_on_empty(attributes, custom_message) has been deprecated.\n" +
+          "Instead of passing a custom_message pass an options Hash { :message => custom_message }."
+      end
+
       [attributes].flatten.each do |attribute|
         value = @base.send(:read_attribute_for_validation, attribute)
         is_empty = value.respond_to?(:empty?) ? value.empty? : false
-        add(attribute, :empty, :default => custom_message) unless !value.nil? && !is_empty
+        add(attribute, :empty, options) if value.nil? || is_empty
       end
     end
 
     # Will add an error message to each of the attributes in +attributes+ that is blank (using Object#blank?).
-    def add_on_blank(attributes, custom_message = nil)
+    def add_on_blank(attributes, options = {})
+      if options && !options.is_a?(Hash)
+        options = { :message => options }
+        ActiveSupport::Deprecation.warn \
+          "ActiveModel::Errors#add_on_blank(attributes, custom_message) has been deprecated.\n" +
+          "Instead of passing a custom_message pass an options Hash { :message => custom_message }."
+      end
+
       [attributes].flatten.each do |attribute|
         value = @base.send(:read_attribute_for_validation, attribute)
-        add(attribute, :blank, :default => custom_message) if value.blank?
+        add(attribute, :blank, options) if value.blank?
       end
     end
 
@@ -262,18 +280,26 @@ module ActiveModel
     # <li><tt>errors.attributes.title.blank</tt></li>
     # <li><tt>errors.messages.blank</tt></li>
     # </ol>
-    def generate_message(attribute, message = :invalid, options = {})
-      message, options[:default] = options[:default], message if options[:default].is_a?(Symbol)
+
+    def generate_message(attribute, type = :invalid, options = {})
+      type = options.delete(:message) if options[:message].is_a?(Symbol)
+
+      if options[:default]
+        ActiveSupport::Deprecation.warn \
+          "ActiveModel::Errors#generate_message(attributes, custom_message) has been deprecated.\n" +
+          "Use ActiveModel::Errors#generate_message(attributes, :message => 'your message') instead."
+        options[:message] = options.delete(:default)
+      end
 
       defaults = @base.class.lookup_ancestors.map do |klass|
-        [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.attributes.#{attribute}.#{message}",
-          :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.#{message}" ]
+        [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.attributes.#{attribute}.#{type}",
+          :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.#{type}" ]
       end
 
-      defaults << options.delete(:default)
-      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{message}"
-      defaults << :"errors.attributes.#{attribute}.#{message}"
-      defaults << :"errors.messages.#{message}"
+      defaults << options.delete(:message)
+      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{type}"
+      defaults << :"errors.attributes.#{attribute}.#{type}"
+      defaults << :"errors.messages.#{type}"
 
       defaults.compact!
       defaults.flatten!
diff --git a/activemodel/lib/active_model/validations/acceptance.rb b/activemodel/lib/active_model/validations/acceptance.rb
index 77c401e0cc..99b8966def 100644
--- a/activemodel/lib/active_model/validations/acceptance.rb
+++ b/activemodel/lib/active_model/validations/acceptance.rb
@@ -9,10 +9,10 @@ module ActiveModel
 
       def validate_each(record, attribute, value)
         unless value == options[:accept]
-          record.errors.add(attribute, :accepted, :default => options[:message])
+          record.errors.add(attribute, :accepted, options.except(:accept, :allow_nil))
         end
       end
-      
+
       def setup(klass)
         # Note: instance_methods.map(&:to_s) is important for 1.9 compatibility
         # as instance_methods returns symbols unlike 1.8 which returns strings.
diff --git a/activemodel/lib/active_model/validations/confirmation.rb b/activemodel/lib/active_model/validations/confirmation.rb
index 5e13db7491..3a80893866 100644
--- a/activemodel/lib/active_model/validations/confirmation.rb
+++ b/activemodel/lib/active_model/validations/confirmation.rb
@@ -6,11 +6,11 @@ module ActiveModel
       def validate_each(record, attribute, value)
         confirmed = record.send(:"#{attribute}_confirmation")
         return if confirmed.nil? || value == confirmed
-        record.errors.add(attribute, :confirmation, :default => options[:message])
+        record.errors.add(attribute, :confirmation, options)
       end
-      
+
       def setup(klass)
-        klass.send(:attr_accessor, *attributes.map { |attribute| :"#{attribute}_confirmation" })        
+        klass.send(:attr_accessor, *attributes.map { |attribute| :"#{attribute}_confirmation" })
       end
     end
 
diff --git a/activemodel/lib/active_model/validations/exclusion.rb b/activemodel/lib/active_model/validations/exclusion.rb
index 599623368f..6fe43c7219 100644
--- a/activemodel/lib/active_model/validations/exclusion.rb
+++ b/activemodel/lib/active_model/validations/exclusion.rb
@@ -9,8 +9,9 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        return unless options[:in].include?(value)
-        record.errors.add(attribute, :exclusion, :default => options[:message], :value => value)
+        if options[:in].include?(value)
+          record.errors.add(attribute, :exclusion, options.except(:in).merge(:value => value))
+        end
       end
     end
 
diff --git a/activemodel/lib/active_model/validations/format.rb b/activemodel/lib/active_model/validations/format.rb
index 3b57d4fd77..6f6933205f 100644
--- a/activemodel/lib/active_model/validations/format.rb
+++ b/activemodel/lib/active_model/validations/format.rb
@@ -5,12 +5,12 @@ module ActiveModel
     class FormatValidator < EachValidator
       def validate_each(record, attribute, value)
         if options[:with] && value.to_s !~ options[:with]
-          record.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+          record.errors.add(attribute, :invalid, options.except(:with).merge(:value => value))
         elsif options[:without] && value.to_s =~ options[:without]
-          record.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+          record.errors.add(attribute, :invalid, options.except(:with).merge(:value => value))
         end
       end
-      
+
       def check_validity!
         unless options.include?(:with) ^ options.include?(:without)  # ^ == xor, or "exclusive or"
           raise ArgumentError, "Either :with or :without must be supplied (but not both)"
diff --git a/activemodel/lib/active_model/validations/inclusion.rb b/activemodel/lib/active_model/validations/inclusion.rb
index e9940dbbf0..863f4da0ff 100644
--- a/activemodel/lib/active_model/validations/inclusion.rb
+++ b/activemodel/lib/active_model/validations/inclusion.rb
@@ -9,8 +9,9 @@ module ActiveModel
       end
 
       def validate_each(record, attribute, value)
-        return if options[:in].include?(value)
-        record.errors.add(attribute, :inclusion, :default => options[:message], :value => value)
+        unless options[:in].include?(value)
+          record.errors.add(attribute, :inclusion, options.except(:in).merge(:value => value))
+        end
       end
     end
 
diff --git a/activemodel/lib/active_model/validations/length.rb b/activemodel/lib/active_model/validations/length.rb
index dc191d3150..77db437a33 100644
--- a/activemodel/lib/active_model/validations/length.rb
+++ b/activemodel/lib/active_model/validations/length.rb
@@ -39,7 +39,8 @@ module ActiveModel
 
         CHECKS.each do |key, validity_check|
           next unless check_value = options[key]
-          custom_message = options[:message] || options[MESSAGES[key]]
+          default_message = options[MESSAGES[key]]
+          options[:message] ||= default_message if default_message
 
           valid_value = if key == :maximum
             value.nil? || value.size.send(validity_check, check_value)
@@ -48,7 +49,10 @@ module ActiveModel
           end
 
           next if valid_value
-          record.errors.add(attribute, MESSAGES[key], :default => custom_message, :count => check_value)
+
+          reserved_options = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
+          record.errors.add(attribute, MESSAGES[key],
+                            options.except(*reserved_options).merge(:count => check_value))
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/numericality.rb b/activemodel/lib/active_model/validations/numericality.rb
index c2e7223939..dcc3befb08 100644
--- a/activemodel/lib/active_model/validations/numericality.rb
+++ b/activemodel/lib/active_model/validations/numericality.rb
@@ -28,13 +28,13 @@ module ActiveModel
         return if options[:allow_nil] && raw_value.nil?
 
         unless value = parse_raw_value_as_a_number(raw_value)
-          record.errors.add(attr_name, :not_a_number, :value => raw_value, :default => options[:message])
+          record.errors.add(attr_name, :not_a_number, filtered_options(raw_value))
           return
         end
 
         if options[:only_integer]
           unless value = parse_raw_value_as_an_integer(raw_value)
-            record.errors.add(attr_name, :not_an_integer, :value => raw_value, :default => options[:message])
+            record.errors.add(attr_name, :not_an_integer, filtered_options(raw_value))
             return
           end
         end
@@ -43,14 +43,14 @@ module ActiveModel
           case option
           when :odd, :even
             unless value.to_i.send(CHECKS[option])
-              record.errors.add(attr_name, option, :value => value, :default => options[:message])
+              record.errors.add(attr_name, option, filtered_options(value))
             end
           else
             option_value = option_value.call(record) if option_value.is_a?(Proc)
             option_value = record.send(option_value) if option_value.is_a?(Symbol)
 
             unless value.send(CHECKS[option], option_value)
-              record.errors.add(attr_name, option, :default => options[:message], :value => value, :count => option_value)
+              record.errors.add(attr_name, option, filtered_options(value).merge(:count => option_value))
             end
           end
         end
@@ -75,6 +75,11 @@ module ActiveModel
         raw_value.to_i if raw_value.to_s =~ /\A[+-]?\d+\Z/
       end
 
+      def filtered_options(value)
+        reserved_options = [:allow_nil, :odd, :even, :not_an_integer, :only_integer, :allow_nil, :less_than]
+        options.except(*reserved_options).merge(:value => value)
+      end
+
     end
 
     module HelperMethods
diff --git a/activemodel/lib/active_model/validations/presence.rb b/activemodel/lib/active_model/validations/presence.rb
index e36bee8115..28c4640b17 100644
--- a/activemodel/lib/active_model/validations/presence.rb
+++ b/activemodel/lib/active_model/validations/presence.rb
@@ -6,7 +6,7 @@ module ActiveModel
   module Validations
     class PresenceValidator < EachValidator
       def validate(record)
-        record.errors.add_on_blank(attributes, options[:message])
+        record.errors.add_on_blank(attributes, options)
       end
     end
 
diff --git a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
index 58a8d179ad..0679e67f84 100644
--- a/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -8,131 +8,131 @@ class I18nGenerateMessageValidationTest < ActiveModel::TestCase
     @person = Person.new
   end
 
-  # validates_inclusion_of: generate_message(attr_name, :inclusion, :default => configuration[:message], :value => value)
+  # validates_inclusion_of: generate_message(attr_name, :inclusion, :message => custom_message, :value => value)
   def test_generate_message_inclusion_with_default_message
-    assert_equal 'is not included in the list', @person.errors.generate_message(:title, :inclusion, :default => nil, :value => 'title')
+    assert_equal 'is not included in the list', @person.errors.generate_message(:title, :inclusion, :value => 'title')
   end
 
   def test_generate_message_inclusion_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :inclusion, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :inclusion, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_exclusion_of: generate_message(attr_name, :exclusion, :default => configuration[:message], :value => value)
+  # validates_exclusion_of: generate_message(attr_name, :exclusion, :message => custom_message, :value => value)
   def test_generate_message_exclusion_with_default_message
-    assert_equal 'is reserved', @person.errors.generate_message(:title, :exclusion, :default => nil, :value => 'title')
+    assert_equal 'is reserved', @person.errors.generate_message(:title, :exclusion, :value => 'title')
   end
 
   def test_generate_message_exclusion_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :exclusion, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :exclusion, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_format_of:  generate_message(attr_name, :invalid, :default => configuration[:message], :value => value)
+  # validates_format_of:  generate_message(attr_name, :invalid, :message => custom_message, :value => value)
   def test_generate_message_invalid_with_default_message
-    assert_equal 'is invalid', @person.errors.generate_message(:title, :invalid, :default => nil, :value => 'title')
+    assert_equal 'is invalid', @person.errors.generate_message(:title, :invalid, :value => 'title')
   end
 
   def test_generate_message_invalid_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :invalid, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :invalid, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_confirmation_of: generate_message(attr_name, :confirmation, :default => configuration[:message])
+  # validates_confirmation_of: generate_message(attr_name, :confirmation, :message => custom_message)
   def test_generate_message_confirmation_with_default_message
-    assert_equal "doesn't match confirmation", @person.errors.generate_message(:title, :confirmation, :default => nil)
+    assert_equal "doesn't match confirmation", @person.errors.generate_message(:title, :confirmation)
   end
 
   def test_generate_message_confirmation_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :message => 'custom message')
   end
 
-  # validates_acceptance_of: generate_message(attr_name, :accepted, :default => configuration[:message])
+  # validates_acceptance_of: generate_message(attr_name, :accepted, :message => custom_message)
   def test_generate_message_accepted_with_default_message
-    assert_equal "must be accepted", @person.errors.generate_message(:title, :accepted, :default => nil)
+    assert_equal "must be accepted", @person.errors.generate_message(:title, :accepted)
   end
 
   def test_generate_message_accepted_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :message => 'custom message')
   end
 
-  # add_on_empty: generate_message(attr, :empty, :default => custom_message)
+  # add_on_empty: generate_message(attr, :empty, :message => custom_message)
   def test_generate_message_empty_with_default_message
-    assert_equal "can't be empty", @person.errors.generate_message(:title, :empty, :default => nil)
+    assert_equal "can't be empty", @person.errors.generate_message(:title, :empty)
   end
 
   def test_generate_message_empty_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :message => 'custom message')
   end
 
-  # add_on_blank: generate_message(attr, :blank, :default => custom_message)
+  # add_on_blank: generate_message(attr, :blank, :message => custom_message)
   def test_generate_message_blank_with_default_message
-    assert_equal "can't be blank", @person.errors.generate_message(:title, :blank, :default => nil)
+    assert_equal "can't be blank", @person.errors.generate_message(:title, :blank)
   end
 
   def test_generate_message_blank_with_custom_message
-    assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :default => 'custom message')
+    assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :message => 'custom message')
   end
 
-  # validates_length_of: generate_message(attr, :too_long, :default => options[:too_long], :count => option_value.end)
+  # validates_length_of: generate_message(attr, :too_long, :message => custom_message, :count => option_value.end)
   def test_generate_message_too_long_with_default_message
-    assert_equal "is too long (maximum is 10 characters)", @person.errors.generate_message(:title, :too_long, :default => nil, :count => 10)
+    assert_equal "is too long (maximum is 10 characters)", @person.errors.generate_message(:title, :too_long, :count => 10)
   end
 
   def test_generate_message_too_long_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_long, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_long, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_length_of: generate_message(attr, :too_short, :default => options[:too_short], :count => option_value.begin)
+  # validates_length_of: generate_message(attr, :too_short, :default => custom_message, :count => option_value.begin)
   def test_generate_message_too_short_with_default_message
-    assert_equal "is too short (minimum is 10 characters)", @person.errors.generate_message(:title, :too_short, :default => nil, :count => 10)
+    assert_equal "is too short (minimum is 10 characters)", @person.errors.generate_message(:title, :too_short, :count => 10)
   end
 
   def test_generate_message_too_short_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_short, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :too_short, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_length_of: generate_message(attr, key, :default => custom_message, :count => option_value)
+  # validates_length_of: generate_message(attr, :wrong_length, :message => custom_message, :count => option_value)
   def test_generate_message_wrong_length_with_default_message
-    assert_equal "is the wrong length (should be 10 characters)", @person.errors.generate_message(:title, :wrong_length, :default => nil, :count => 10)
+    assert_equal "is the wrong length (should be 10 characters)", @person.errors.generate_message(:title, :wrong_length, :count => 10)
   end
 
   def test_generate_message_wrong_length_with_custom_message
-    assert_equal 'custom message 10', @person.errors.generate_message(:title, :wrong_length, :default => 'custom message %{count}', :count => 10)
+    assert_equal 'custom message 10', @person.errors.generate_message(:title, :wrong_length, :message => 'custom message %{count}', :count => 10)
   end
 
-  # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :default => configuration[:message])
+  # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :message => custom_message)
   def test_generate_message_not_a_number_with_default_message
-    assert_equal "is not a number", @person.errors.generate_message(:title, :not_a_number, :default => nil, :value => 'title')
+    assert_equal "is not a number", @person.errors.generate_message(:title, :not_a_number, :value => 'title')
   end
 
   def test_generate_message_not_a_number_with_custom_message
-    assert_equal 'custom message title', @person.errors.generate_message(:title, :not_a_number, :default => 'custom message %{value}', :value => 'title')
+    assert_equal 'custom message title', @person.errors.generate_message(:title, :not_a_number, :message => 'custom message %{value}', :value => 'title')
   end
 
-  # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => configuration[:message])
+  # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => custom_message)
   def test_generate_message_greater_than_with_default_message
-    assert_equal "must be greater than 10", @person.errors.generate_message(:title, :greater_than, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be greater than 10", @person.errors.generate_message(:title, :greater_than, :value => 'title', :count => 10)
   end
 
   def test_generate_message_greater_than_or_equal_to_with_default_message
-    assert_equal "must be greater than or equal to 10", @person.errors.generate_message(:title, :greater_than_or_equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be greater than or equal to 10", @person.errors.generate_message(:title, :greater_than_or_equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_equal_to_with_default_message
-    assert_equal "must be equal to 10", @person.errors.generate_message(:title, :equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be equal to 10", @person.errors.generate_message(:title, :equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_less_than_with_default_message
-    assert_equal "must be less than 10", @person.errors.generate_message(:title, :less_than, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be less than 10", @person.errors.generate_message(:title, :less_than, :value => 'title', :count => 10)
   end
 
   def test_generate_message_less_than_or_equal_to_with_default_message
-    assert_equal "must be less than or equal to 10", @person.errors.generate_message(:title, :less_than_or_equal_to, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be less than or equal to 10", @person.errors.generate_message(:title, :less_than_or_equal_to, :value => 'title', :count => 10)
   end
 
   def test_generate_message_odd_with_default_message
-    assert_equal "must be odd", @person.errors.generate_message(:title, :odd, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be odd", @person.errors.generate_message(:title, :odd, :value => 'title', :count => 10)
   end
 
   def test_generate_message_even_with_default_message
-    assert_equal "must be even", @person.errors.generate_message(:title, :even, :default => nil, :value => 'title', :count => 10)
+    assert_equal "must be even", @person.errors.generate_message(:title, :even, :value => 'title', :count => 10)
   end
 end
diff --git a/activemodel/test/cases/validations/i18n_validation_test.rb b/activemodel/test/cases/validations/i18n_validation_test.rb
index 547d80f46e..e9f0e430fe 100644
--- a/activemodel/test/cases/validations/i18n_validation_test.rb
+++ b/activemodel/test/cases/validations/i18n_validation_test.rb
@@ -22,23 +22,23 @@ class I18nValidationTest < ActiveModel::TestCase
   end
 
   def test_errors_add_on_empty_generates_message
-    @person.errors.expects(:generate_message).with(:title, :empty, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :empty, {})
     @person.errors.add_on_empty :title
   end
 
   def test_errors_add_on_empty_generates_message_with_custom_default_message
-    @person.errors.expects(:generate_message).with(:title, :empty, {:default => 'custom'})
-    @person.errors.add_on_empty :title, 'custom'
+    @person.errors.expects(:generate_message).with(:title, :empty, {:message => 'custom'})
+    @person.errors.add_on_empty :title, :message => 'custom'
   end
 
   def test_errors_add_on_blank_generates_message
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => nil})
+    @person.errors.expects(:generate_message).with(:title, :blank, {})
     @person.errors.add_on_blank :title
   end
 
   def test_errors_add_on_blank_generates_message_with_custom_default_message
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => 'custom'})
-    @person.errors.add_on_blank :title, 'custom'
+    @person.errors.expects(:generate_message).with(:title, :blank, {:message => 'custom'})
+    @person.errors.add_on_blank :title, :message => 'custom'
   end
 
   def test_full_message_encoding
@@ -62,441 +62,272 @@ class I18nValidationTest < ActiveModel::TestCase
   end
 
   # ActiveModel::Validations
+
+  # A set of common cases for ActiveModel::Validations message generation that
+  # are used to generate tests to keep things DRY
+  #
+  COMMON_CASES = [
+  # [ case,                                validation_options,            generate_message_options]
+    [ "given no options",                  {},                            {}],
+    [ "given custom message",              {:message => "custom"},        {:message => "custom"}],
+    [ "given if condition",                {:if     => lambda { true }},  {}],
+    [ "given unless condition",            {:unless => lambda { false }}, {}],
+    [ "given option that is not reserved", {:format => "jpg"},            {:format => "jpg" }]
+  ]
+
   # validates_confirmation_of w/ mocha
-  def test_validates_confirmation_of_generates_message
-    Person.validates_confirmation_of :title
-    @person.title_confirmation = 'foo'
-    @person.errors.expects(:generate_message).with(:title, :confirmation, {:default => nil})
-    @person.valid?
-  end
 
-  def test_validates_confirmation_of_generates_message_with_custom_default_message
-    Person.validates_confirmation_of :title, :message => 'custom'
-    @person.title_confirmation = 'foo'
-    @person.errors.expects(:generate_message).with(:title, :confirmation, {:default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_confirmation_of on generated message #{name}" do
+      Person.validates_confirmation_of :title, validation_options
+      @person.title_confirmation = 'foo'
+      @person.errors.expects(:generate_message).with(:title, :confirmation, generate_message_options)
+      @person.valid?
+    end
   end
 
   # validates_acceptance_of w/ mocha
 
-  def test_validates_acceptance_of_generates_message
-    Person.validates_acceptance_of :title, :allow_nil => false
-    @person.errors.expects(:generate_message).with(:title, :accepted, {:default => nil})
-    @person.valid?
-  end
-
-  def test_validates_acceptance_of_generates_message_with_custom_default_message
-    Person.validates_acceptance_of :title, :message => 'custom', :allow_nil => false
-    @person.errors.expects(:generate_message).with(:title, :accepted, {:default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_acceptance_of on generated message #{name}" do
+      Person.validates_acceptance_of :title, validation_options.merge(:allow_nil => false)
+      @person.errors.expects(:generate_message).with(:title, :accepted, generate_message_options)
+      @person.valid?
+    end
   end
 
   # validates_presence_of w/ mocha
 
-  def test_validates_presence_of_generates_message
-    Person.validates_presence_of :title
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => nil})
-    @person.valid?
-  end
-
-  def test_validates_presence_of_generates_message_with_custom_default_message
-    Person.validates_presence_of :title, :message => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :blank, {:default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_presence_of on generated message #{name}" do
+      Person.validates_presence_of :title, validation_options
+      @person.errors.expects(:generate_message).with(:title, :blank, generate_message_options)
+      @person.valid?
+    end
   end
 
-  # validates_length_of :within w/ mocha
+  # validates_length_of :within too short w/ mocha
 
-  def test_validates_length_of_within_generates_message_with_title_too_short
-    Person.validates_length_of :title, :within => 3..5
-    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3, :default => nil})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_length_of for :withing on generated message when too short #{name}" do
+      Person.validates_length_of :title, validation_options.merge(:within => 3..5)
+      @person.errors.expects(:generate_message).with(:title, :too_short, generate_message_options.merge(:count => 3))
+      @person.valid?
+    end
   end
 
-  def test_validates_length_of_within_generates_message_with_title_too_short_and_custom_default_message
-    Person.validates_length_of :title, :within => 3..5, :too_short => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :too_short, {:count => 3, :default => 'custom'})
-    @person.valid?
-  end
-
-  def test_validates_length_of_within_generates_message_with_title_too_long
-    Person.validates_length_of :title, :within => 3..5
-    @person.title = 'this title is too long'
-    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5, :default => nil})
-    @person.valid?
-  end
+  # validates_length_of :within too long w/ mocha
 
-  def test_validates_length_of_within_generates_message_with_title_too_long_and_custom_default_message
-    Person.validates_length_of :title, :within => 3..5, :too_long => 'custom'
-    @person.title = 'this title is too long'
-    @person.errors.expects(:generate_message).with(:title, :too_long, {:count => 5, :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_length_of for :too_long generated message #{name}" do
+      Person.validates_length_of :title, validation_options.merge(:within => 3..5)
+      @person.title = 'this title is too long'
+      @person.errors.expects(:generate_message).with(:title, :too_long, generate_message_options.merge(:count => 5))
+      @person.valid?
+    end
   end
 
   # validates_length_of :is w/ mocha
 
-  def test_validates_length_of_is_generates_message
-    Person.validates_length_of :title, :is => 5
-    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5, :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_length_of_is_generates_message_with_custom_default_message
-    Person.validates_length_of :title, :is => 5, :message => 'custom'
-    @person.errors.expects(:generate_message).with(:title, :wrong_length, {:count => 5, :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_length_of for :is on generated message #{name}" do
+      Person.validates_length_of :title, validation_options.merge(:is => 5)
+      @person.errors.expects(:generate_message).with(:title, :wrong_length, generate_message_options.merge(:count => 5))
+      @person.valid?
+    end
   end
 
   # validates_format_of w/ mocha
 
-  def test_validates_format_of_generates_message
-    Person.validates_format_of :title, :with => /^[1-9][0-9]*$/
-    @person.title = '72x'
-    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x', :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_format_of_generates_message_with_custom_default_message
-    Person.validates_format_of :title, :with => /^[1-9][0-9]*$/, :message => 'custom'
-    @person.title = '72x'
-    @person.errors.expects(:generate_message).with(:title, :invalid, {:value => '72x', :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_format_of on generated message #{name}" do
+      Person.validates_format_of :title, validation_options.merge(:with => /^[1-9][0-9]*$/)
+      @person.title = '72x'
+      @person.errors.expects(:generate_message).with(:title, :invalid, generate_message_options.merge(:value => '72x'))
+      @person.valid?
+    end
   end
 
   # validates_inclusion_of w/ mocha
 
-  def test_validates_inclusion_of_generates_message
-    Person.validates_inclusion_of :title, :in => %w(a b c)
-    @person.title = 'z'
-    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z', :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_inclusion_of_generates_message_with_custom_default_message
-    Person.validates_inclusion_of :title, :in => %w(a b c), :message => 'custom'
-    @person.title = 'z'
-    @person.errors.expects(:generate_message).with(:title, :inclusion, {:value => 'z', :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_inclusion_of on generated message #{name}" do
+      Person.validates_inclusion_of :title, validation_options.merge(:in => %w(a b c))
+      @person.title = 'z'
+      @person.errors.expects(:generate_message).with(:title, :inclusion, generate_message_options.merge(:value => 'z'))
+      @person.valid?
+    end
   end
 
   # validates_exclusion_of w/ mocha
 
-  def test_validates_exclusion_of_generates_message
-    Person.validates_exclusion_of :title, :in => %w(a b c)
-    @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a', :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_exclusion_of_generates_message_with_custom_default_message
-    Person.validates_exclusion_of :title, :in => %w(a b c), :message => 'custom'
-    @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :exclusion, {:value => 'a', :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_exclusion_of generated message #{name}" do
+      Person.validates_exclusion_of :title, validation_options.merge(:in => %w(a b c))
+      @person.title = 'a'
+      @person.errors.expects(:generate_message).with(:title, :exclusion, generate_message_options.merge(:value => 'a'))
+      @person.valid?
+    end
   end
 
   # validates_numericality_of without :only_integer w/ mocha
 
-  def test_validates_numericality_of_generates_message
-    Person.validates_numericality_of :title
-    @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_numericality_of_generates_message_with_custom_default_message
-    Person.validates_numericality_of :title, :message => 'custom'
-    @person.title = 'a'
-    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_numericality_of generated message #{name}" do
+      Person.validates_numericality_of :title, validation_options
+      @person.title = 'a'
+      @person.errors.expects(:generate_message).with(:title, :not_a_number, generate_message_options.merge(:value => 'a'))
+      @person.valid?
+    end
   end
 
   # validates_numericality_of with :only_integer w/ mocha
 
-  def test_validates_numericality_of_only_integer_generates_message
-    Person.validates_numericality_of :title, :only_integer => true
-    @person.title = '0.0'
-    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0', :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_numericality_of_only_integer_generates_message_with_custom_default_message
-    Person.validates_numericality_of :title, :only_integer => true, :message => 'custom'
-    @person.title = '0.0'
-    @person.errors.expects(:generate_message).with(:title, :not_an_integer, {:value => '0.0', :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_numericality_of for :only_integer on generated message #{name}" do
+      Person.validates_numericality_of :title, validation_options.merge(:only_integer => true)
+      @person.title = '0.0'
+      @person.errors.expects(:generate_message).with(:title, :not_an_integer, generate_message_options.merge(:value => '0.0'))
+      @person.valid?
+    end
   end
 
   # validates_numericality_of :odd w/ mocha
 
-  def test_validates_numericality_of_odd_generates_message
-    Person.validates_numericality_of :title, :only_integer => true, :odd => true
-    @person.title = 0
-    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0, :default => nil})
-    @person.valid?
-  end
-
-  def test_validates_numericality_of_odd_generates_message_with_custom_default_message
-    Person.validates_numericality_of :title, :only_integer => true, :odd => true, :message => 'custom'
-    @person.title = 0
-    @person.errors.expects(:generate_message).with(:title, :odd, {:value => 0, :default => 'custom'})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_numericality_of for :odd on generated message #{name}" do
+      Person.validates_numericality_of :title, validation_options.merge(:only_integer => true, :odd => true)
+      @person.title = 0
+      @person.errors.expects(:generate_message).with(:title, :odd, generate_message_options.merge(:value => 0))
+      @person.valid?
+    end
   end
 
   # validates_numericality_of :less_than w/ mocha
 
-  def test_validates_numericality_of_less_than_generates_message
-    Person.validates_numericality_of :title, :only_integer => true, :less_than => 0
-    @person.title = 1
-    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0, :default => nil})
-    @person.valid?
+  COMMON_CASES.each do |name, validation_options, generate_message_options|
+    test "validates_numericality_of for :less_than on generated message #{name}" do
+      Person.validates_numericality_of :title, validation_options.merge(:only_integer => true, :less_than => 0)
+      @person.title = 1
+      @person.errors.expects(:generate_message).with(:title, :less_than, generate_message_options.merge(:value => 1, :count => 0))
+      @person.valid?
+    end
   end
 
-  def test_validates_numericality_of_less_than_odd_generates_message_with_custom_default_message
-    Person.validates_numericality_of :title, :only_integer => true, :less_than => 0, :message => 'custom'
-    @person.title = 1
-    @person.errors.expects(:generate_message).with(:title, :less_than, {:value => 1, :count => 0, :default => 'custom'})
-    @person.valid?
-  end
 
-  # validates_confirmation_of w/o mocha
+  # To make things DRY this macro is defined to define 3 tests for every validation case.
+  def self.set_expectations_for_validation(validation, error_type, &block_that_sets_validation)
+    # test "validates_confirmation_of finds custom model key translation when blank"
+    test "#{validation} finds custom model key translation when #{error_type}" do
+      I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {error_type => 'custom message'}}}}}}
+      I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}
 
-  def test_validates_confirmation_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:confirmation => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:confirmation => 'global message'}}
+      yield(@person, {})
+      @person.valid?
+      assert_equal ['custom message'], @person.errors[:title]
+    end
 
-    Person.validates_confirmation_of :title
-    @person.title_confirmation = 'foo'
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
+    # test "validates_confirmation_of finds custom model key translation with interpolation when blank"
+    test "#{validation} finds custom model key translation with interpolation when #{error_type}" do
+      I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {error_type => 'custom message with %{extra}'}}}}}}
+      I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}
 
-  def test_validates_confirmation_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:confirmation => 'global message'}}
+      yield(@person, {:extra => "extra information"})
+      @person.valid?
+      assert_equal ['custom message with extra information'], @person.errors[:title]
+    end
 
-    Person.validates_confirmation_of :title
-    @person.title_confirmation = 'foo'
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
-  end
+    # test "validates_confirmation_of finds global default key translation when blank"
+    test "#{validation} finds global default key translation when #{error_type}" do
+      I18n.backend.store_translations 'en', :errors => {:messages => {error_type => 'global message'}}
 
-  # validates_acceptance_of w/o mocha
-
-  def test_validates_acceptance_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:accepted => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:accepted => 'global message'}}
-
-    Person.validates_acceptance_of :title, :allow_nil => false
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
+      yield(@person, {})
+      @person.valid?
+      assert_equal ['global message'], @person.errors[:title]
+    end
   end
 
-  def test_validates_acceptance_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:accepted => 'global message'}}
+  # validates_confirmation_of w/o mocha
 
-    Person.validates_acceptance_of :title, :allow_nil => false
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_confirmation_of", :confirmation do |person, options_to_merge|
+    Person.validates_confirmation_of :title, options_to_merge
+    person.title_confirmation = 'foo'
   end
 
-  # validates_presence_of w/o mocha
-
-  def test_validates_presence_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:blank => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:blank => 'global message'}}
+  # validates_acceptance_of w/o mocha
 
-    Person.validates_presence_of :title
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
+  set_expectations_for_validation "validates_acceptance_of", :accepted do |person, options_to_merge|
+    Person.validates_acceptance_of :title, options_to_merge.merge(:allow_nil => false)
   end
 
-  def test_validates_presence_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:blank => 'global message'}}
+  # validates_presence_of w/o mocha
 
-    Person.validates_presence_of :title
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_presence_of", :blank do |person, options_to_merge|
+    Person.validates_presence_of :title, options_to_merge
   end
 
   # validates_length_of :within w/o mocha
 
-  def test_validates_length_of_within_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:too_short => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:too_short => 'global message'}}
-
-    Person.validates_length_of :title, :within => 3..5
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
+  set_expectations_for_validation "validates_length_of", :too_short do |person, options_to_merge|
+    Person.validates_length_of :title, options_to_merge.merge(:within => 3..5)
   end
 
-  def test_validates_length_of_within_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:too_short => 'global message'}}
-
-    Person.validates_length_of :title, :within => 3..5
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_length_of", :too_long do |person, options_to_merge|
+    Person.validates_length_of :title, options_to_merge.merge(:within => 3..5)
+    person.title = "too long"
   end
 
   # validates_length_of :is w/o mocha
 
-  def test_validates_length_of_is_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:wrong_length => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:wrong_length => 'global message'}}
-
-    Person.validates_length_of :title, :is => 5
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_length_of_is_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:wrong_length => 'global message'}}
-
-    Person.validates_length_of :title, :is => 5
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_length_of", :wrong_length do |person, options_to_merge|
+    Person.validates_length_of :title, options_to_merge.merge(:is => 5)
   end
 
   # validates_format_of w/o mocha
 
-  def test_validates_format_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:invalid => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:invalid => 'global message'}}
-
-    Person.validates_format_of :title, :with => /^[1-9][0-9]*$/
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_format_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:invalid => 'global message'}}
-
-    Person.validates_format_of :title, :with => /^[1-9][0-9]*$/
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_format_of", :invalid do |person, options_to_merge|
+    Person.validates_format_of :title, options_to_merge.merge(:with => /^[1-9][0-9]*$/)
   end
 
   # validates_inclusion_of w/o mocha
 
-  def test_validates_inclusion_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:inclusion => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:inclusion => 'global message'}}
-
-    Person.validates_inclusion_of :title, :in => %w(a b c)
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_inclusion_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:inclusion => 'global message'}}
-
-    Person.validates_inclusion_of :title, :in => %w(a b c)
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_inclusion_of", :inclusion do |person, options_to_merge|
+    Person.validates_inclusion_of :title, options_to_merge.merge(:in => %w(a b c))
   end
 
   # validates_exclusion_of w/o mocha
 
-  def test_validates_exclusion_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:exclusion => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:exclusion => 'global message'}}
-
-    Person.validates_exclusion_of :title, :in => %w(a b c)
-    @person.title = 'a'
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_exclusion_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:exclusion => 'global message'}}
-
-    Person.validates_exclusion_of :title, :in => %w(a b c)
-    @person.title = 'a'
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_exclusion_of", :exclusion do |person, options_to_merge|
+    Person.validates_exclusion_of :title, options_to_merge.merge(:in => %w(a b c))
+    person.title = 'a'
   end
 
   # validates_numericality_of without :only_integer w/o mocha
 
-  def test_validates_numericality_of_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:not_a_number => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:not_a_number => 'global message'}}
-
-    Person.validates_numericality_of :title
-    @person.title = 'a'
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_numericality_of_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:not_a_number => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true
-    @person.title = 'a'
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_numericality_of", :not_a_number do |person, options_to_merge|
+    Person.validates_numericality_of :title, options_to_merge
+    person.title = 'a'
   end
 
   # validates_numericality_of with :only_integer w/o mocha
 
-  def test_validates_numericality_of_only_integer_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:not_an_integer => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:not_an_integer => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true
-    @person.title = '1.0'
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_numericality_of_only_integer_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:not_an_integer => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true
-    @person.title = '1.0'
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_numericality_of", :not_an_integer do |person, options_to_merge|
+    Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true)
+    person.title = '1.0'
   end
 
   # validates_numericality_of :odd w/o mocha
 
-  def test_validates_numericality_of_odd_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:odd => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:odd => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true, :odd => true
-    @person.title = 0
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_numericality_of_odd_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:odd => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true, :odd => true
-    @person.title = 0
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_numericality_of", :odd do |person, options_to_merge|
+    Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true, :odd => true)
+    person.title = 0
   end
 
   # validates_numericality_of :less_than w/o mocha
 
-  def test_validates_numericality_of_less_than_finds_custom_model_key_translation
-    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:less_than => 'custom message'}}}}}}
-    I18n.backend.store_translations 'en', :errors => {:messages => {:less_than => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true, :less_than => 0
-    @person.title = 1
-    @person.valid?
-    assert_equal ['custom message'], @person.errors[:title]
-  end
-
-  def test_validates_numericality_of_less_than_finds_global_default_translation
-    I18n.backend.store_translations 'en', :errors => {:messages => {:less_than => 'global message'}}
-
-    Person.validates_numericality_of :title, :only_integer => true, :less_than => 0
-    @person.title = 1
-    @person.valid?
-    assert_equal ['global message'], @person.errors[:title]
+  set_expectations_for_validation "validates_numericality_of", :less_than do |person, options_to_merge|
+    Person.validates_numericality_of :title, options_to_merge.merge(:only_integer => true, :less_than => 0)
+    person.title = 1
   end
 
   # test with validates_with
-- 
cgit v1.2.3


From 0421fb7a913c1c8a7e07a395106bbc65e75e9d45 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@gmail.com>
Date: Mon, 21 Jun 2010 12:17:24 +0200
Subject: Refactor previous commit a bit [#4057 state:resolved]

---
 activemodel/lib/active_model/errors.rb                   | 11 +++++++----
 activemodel/lib/active_model/validations/exclusion.rb    |  2 +-
 activemodel/lib/active_model/validations/format.rb       |  4 ++--
 activemodel/lib/active_model/validations/inclusion.rb    |  2 +-
 activemodel/lib/active_model/validations/length.rb       |  4 ++--
 activemodel/lib/active_model/validations/numericality.rb |  6 +++---
 activemodel/lib/active_model/validations/with.rb         |  3 ---
 7 files changed, 16 insertions(+), 16 deletions(-)

(limited to 'activemodel')

diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index b4660f3587..d943e044a7 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -61,6 +61,8 @@ module ActiveModel
   class Errors < ActiveSupport::OrderedHash
     include DeprecatedErrorMethods
 
+    CALLBACKS_OPTIONS = [:if, :unless, :on, :allow_nil, :allow_blank]
+
     # Pass in the instance of the object that is using the errors object.
     # 
     #   class Person
@@ -183,11 +185,12 @@ module ActiveModel
     def add(attribute, message = nil, options = {})
       message ||= :invalid
 
-      validation_conditionals = [:if, :unless, :on]
-
-      message = generate_message(attribute, message, options.except(*validation_conditionals)) if message.is_a?(Symbol)
+      if message.is_a?(Symbol)
+        message = generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
+      elsif message.is_a?(Proc)
+        message = message.call
+      end
 
-      message = message.call if message.is_a?(Proc)
       self[attribute] << message
     end
 
diff --git a/activemodel/lib/active_model/validations/exclusion.rb b/activemodel/lib/active_model/validations/exclusion.rb
index 6fe43c7219..4138892786 100644
--- a/activemodel/lib/active_model/validations/exclusion.rb
+++ b/activemodel/lib/active_model/validations/exclusion.rb
@@ -10,7 +10,7 @@ module ActiveModel
 
       def validate_each(record, attribute, value)
         if options[:in].include?(value)
-          record.errors.add(attribute, :exclusion, options.except(:in).merge(:value => value))
+          record.errors.add(attribute, :exclusion, options.except(:in).merge!(:value => value))
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/format.rb b/activemodel/lib/active_model/validations/format.rb
index 6f6933205f..104f403492 100644
--- a/activemodel/lib/active_model/validations/format.rb
+++ b/activemodel/lib/active_model/validations/format.rb
@@ -5,9 +5,9 @@ module ActiveModel
     class FormatValidator < EachValidator
       def validate_each(record, attribute, value)
         if options[:with] && value.to_s !~ options[:with]
-          record.errors.add(attribute, :invalid, options.except(:with).merge(:value => value))
+          record.errors.add(attribute, :invalid, options.except(:with).merge!(:value => value))
         elsif options[:without] && value.to_s =~ options[:without]
-          record.errors.add(attribute, :invalid, options.except(:with).merge(:value => value))
+          record.errors.add(attribute, :invalid, options.except(:without).merge!(:value => value))
         end
       end
 
diff --git a/activemodel/lib/active_model/validations/inclusion.rb b/activemodel/lib/active_model/validations/inclusion.rb
index 863f4da0ff..049b093618 100644
--- a/activemodel/lib/active_model/validations/inclusion.rb
+++ b/activemodel/lib/active_model/validations/inclusion.rb
@@ -10,7 +10,7 @@ module ActiveModel
 
       def validate_each(record, attribute, value)
         unless options[:in].include?(value)
-          record.errors.add(attribute, :inclusion, options.except(:in).merge(:value => value))
+          record.errors.add(attribute, :inclusion, options.except(:in).merge!(:value => value))
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/length.rb b/activemodel/lib/active_model/validations/length.rb
index 77db437a33..c8a77ad666 100644
--- a/activemodel/lib/active_model/validations/length.rb
+++ b/activemodel/lib/active_model/validations/length.rb
@@ -7,6 +7,7 @@ module ActiveModel
       CHECKS    = { :is => :==, :minimum => :>=, :maximum => :<= }.freeze
 
       DEFAULT_TOKENIZER = lambda { |value| value.split(//) }
+      RESERVED_OPTIONS  = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
 
       def initialize(options)
         if range = (options.delete(:in) || options.delete(:within))
@@ -50,9 +51,8 @@ module ActiveModel
 
           next if valid_value
 
-          reserved_options = [:minimum, :maximum, :within, :is, :tokenizer, :too_short, :too_long]
           record.errors.add(attribute, MESSAGES[key],
-                            options.except(*reserved_options).merge(:count => check_value))
+                            options.except(*RESERVED_OPTIONS).merge!(:count => check_value))
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/numericality.rb b/activemodel/lib/active_model/validations/numericality.rb
index dcc3befb08..b6aff7aa6b 100644
--- a/activemodel/lib/active_model/validations/numericality.rb
+++ b/activemodel/lib/active_model/validations/numericality.rb
@@ -7,6 +7,8 @@ module ActiveModel
                  :equal_to => :==, :less_than => :<, :less_than_or_equal_to => :<=,
                  :odd => :odd?, :even => :even? }.freeze
 
+      RESERVED_OPTIONS = CHECKS.keys + [:only_integer]
+
       def initialize(options)
         super(options.reverse_merge(:only_integer => false, :allow_nil => false))
       end
@@ -76,10 +78,8 @@ module ActiveModel
       end
 
       def filtered_options(value)
-        reserved_options = [:allow_nil, :odd, :even, :not_an_integer, :only_integer, :allow_nil, :less_than]
-        options.except(*reserved_options).merge(:value => value)
+        options.except(*RESERVED_OPTIONS).merge!(:value => value)
       end
-
     end
 
     module HelperMethods
diff --git a/activemodel/lib/active_model/validations/with.rb b/activemodel/lib/active_model/validations/with.rb
index a2e870d714..200efd4eb5 100644
--- a/activemodel/lib/active_model/validations/with.rb
+++ b/activemodel/lib/active_model/validations/with.rb
@@ -1,6 +1,4 @@
 module ActiveModel
-
-  # == Active Model validates_with method
   module Validations
     module HelperMethods
       private
@@ -11,7 +9,6 @@ module ActiveModel
     end
 
     module ClassMethods
-
       # Passes the record off to the class or classes specified and allows them
       # to add errors based on more complex conditions.
       #
-- 
cgit v1.2.3


From 6ea967729fef4e3155fb7a50813b503a0bfdc07f Mon Sep 17 00:00:00 2001
From: Santiago Pastorino <santiago@wyeworks.com>
Date: Tue, 22 Jun 2010 08:13:58 -0300
Subject: Avoid method redefined warning
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: José Valim <jose.valim@gmail.com>
---
 activemodel/test/cases/validations/callbacks_test.rb | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

(limited to 'activemodel')

diff --git a/activemodel/test/cases/validations/callbacks_test.rb b/activemodel/test/cases/validations/callbacks_test.rb
index 67b21eb106..1cf09758f9 100644
--- a/activemodel/test/cases/validations/callbacks_test.rb
+++ b/activemodel/test/cases/validations/callbacks_test.rb
@@ -5,7 +5,8 @@ class Dog
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
 
-  attr_accessor :name, :history
+  attr_accessor :name
+  attr_writer   :history
 
   def history
     @history ||= []
-- 
cgit v1.2.3


From c0fc084e937ff045a75227cee52c801589517435 Mon Sep 17 00:00:00 2001
From: Neeraj Singh <neerajdotname@gmail.com>
Date: Tue, 22 Jun 2010 14:00:21 -0400
Subject: should be able to run ActiveModel validations_test [#4933
 state:resolved]
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: José Valim <jose.valim@gmail.com>
---
 activemodel/test/cases/helper.rb | 1 +
 1 file changed, 1 insertion(+)

(limited to 'activemodel')

diff --git a/activemodel/test/cases/helper.rb b/activemodel/test/cases/helper.rb
index a81584bbad..a32f11484a 100644
--- a/activemodel/test/cases/helper.rb
+++ b/activemodel/test/cases/helper.rb
@@ -6,6 +6,7 @@ $:.unshift(lib) unless $:.include?('lib') || $:.include?(lib)
 require 'config'
 require 'active_model'
 require 'active_support/core_ext/string/access'
+require 'active_support/core_ext/hash/except'
 
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
-- 
cgit v1.2.3


From e8c064bbe0fb5e07c7ceaa45d0cafa3c4ef01ab0 Mon Sep 17 00:00:00 2001
From: Josh Kalderimis <josh.kalderimis@gmail.com>
Date: Wed, 23 Jun 2010 14:41:28 +0200
Subject: Regression with how base errors messages are added to a model. Works
 correctly for both string error messages and symbol translated messages.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: José Valim <jose.valim@gmail.com>
---
 .../lib/active_model/deprecated_error_methods.rb    |  2 +-
 activemodel/lib/active_model/errors.rb              |  2 +-
 activemodel/test/cases/validations_test.rb          | 21 ++++++++++++++++++---
 3 files changed, 20 insertions(+), 5 deletions(-)

(limited to 'activemodel')

diff --git a/activemodel/lib/active_model/deprecated_error_methods.rb b/activemodel/lib/active_model/deprecated_error_methods.rb
index dd8050c549..adc50773d9 100644
--- a/activemodel/lib/active_model/deprecated_error_methods.rb
+++ b/activemodel/lib/active_model/deprecated_error_methods.rb
@@ -16,7 +16,7 @@ module ActiveModel
     end
 
     def add_to_base(msg)
-      ActiveSupport::Deprecation.warn "Errors#add_to_base(msg) has been deprecated, use Errors#[:base] << msg instead"
+      ActiveSupport::Deprecation.warn "Errors#add_to_base(msg) has been deprecated, use Errors#add(:base, msg) instead"
       self[:base] << msg
     end
 
diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index d943e044a7..ae7822d8d5 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -308,7 +308,7 @@ module ActiveModel
       defaults.flatten!
 
       key = defaults.shift
-      value = @base.send(:read_attribute_for_validation, attribute)
+      value = (attribute != :base ? @base.send(:read_attribute_for_validation, attribute) : nil)
 
       options = {
         :default => defaults,
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
index af195af080..228c1c074f 100644
--- a/activemodel/test/cases/validations_test.rb
+++ b/activemodel/test/cases/validations_test.rb
@@ -83,10 +83,9 @@ class ValidationsTest < ActiveModel::TestCase
     r = Reply.new
     r.content = "Mismatch"
     r.valid?
-    r.errors[:base] << "Reply is not dignifying"
+    r.errors.add(:base, "Reply is not dignifying")
 
-    errors = []
-    r.errors.to_a.each { |error| errors << error }
+    errors = r.errors.to_a.inject([]) { |result, error| result + [error] }
 
     assert_equal ["Reply is not dignifying"], r.errors[:base]
 
@@ -95,6 +94,22 @@ class ValidationsTest < ActiveModel::TestCase
     assert_equal 2, r.errors.count
   end
 
+  def test_errors_on_base_with_symbol_message
+    r = Reply.new
+    r.content = "Mismatch"
+    r.valid?
+    r.errors.add(:base, :invalid)
+
+    errors = r.errors.to_a.inject([]) { |result, error| result + [error] }
+
+    assert_equal ["is invalid"], r.errors[:base]
+
+    assert errors.include?("Title is Empty")
+    assert errors.include?("is invalid")
+
+    assert_equal 2, r.errors.count
+  end
+
   def test_errors_empty_after_errors_on_check
     t = Topic.new
     assert t.errors[:id].empty?
-- 
cgit v1.2.3


From 7bd85a8fc2d216a5e2b1d0380df572f782a54d1c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Jos=C3=A9=20Valim?= <jose.valim@gmail.com>
Date: Sat, 26 Jun 2010 11:57:43 +0200
Subject: Work around the fact the JSON gem was overwriting to_json
 implementation for all Ruby core classes.

This is required because the JSON gem is incompatible with Rails behavior and was not allowing ActiveModel::Errors to be serialized.
So we need to ensure Rails implementation is the one triggered. [#4890 state:resolved]
---
 activemodel/lib/active_model/errors.rb              | 17 +++++++----------
 .../cases/validations/presence_validation_test.rb   |  2 +-
 activemodel/test/cases/validations_test.rb          | 21 +++++++++++++++------
 3 files changed, 23 insertions(+), 17 deletions(-)

(limited to 'activemodel')

diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index ae7822d8d5..d42fc5291d 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -3,6 +3,7 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/reverse_merge'
 require 'active_support/ordered_hash'
 
 module ActiveModel
@@ -164,15 +165,12 @@ module ActiveModel
     #   #    <error>name must be specified</error>
     #   #  </errors>
     def to_xml(options={})
-      require 'builder' unless defined? ::Builder
-      options[:root]    ||= "errors"
-      options[:indent]  ||= 2
-      options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
-
-      options[:builder].instruct! unless options.delete(:skip_instruct)
-      options[:builder].errors do |e|
-        to_a.each { |error| e.error(error) }
-      end
+      to_a.to_xml options.reverse_merge(:root => "errors", :skip_types => true)
+    end
+
+    # Returns an array as JSON representation for this object.
+    def as_json(options=nil)
+      to_a
     end
 
     # Adds +message+ to the error messages on +attribute+, which will be returned on a call to
@@ -283,7 +281,6 @@ module ActiveModel
     # <li><tt>errors.attributes.title.blank</tt></li>
     # <li><tt>errors.messages.blank</tt></li>
     # </ol>
-
     def generate_message(attribute, type = :invalid, options = {})
       type = options.delete(:message) if options[:message].is_a?(Symbol)
 
diff --git a/activemodel/test/cases/validations/presence_validation_test.rb b/activemodel/test/cases/validations/presence_validation_test.rb
index b1450586a8..510c13a7c3 100644
--- a/activemodel/test/cases/validations/presence_validation_test.rb
+++ b/activemodel/test/cases/validations/presence_validation_test.rb
@@ -32,7 +32,7 @@ class PresenceValidationTest < ActiveModel::TestCase
     assert t.valid?
   end
 
-  test 'accepts array arguments' do
+  def test_accepts_array_arguments
     Topic.validates_presence_of %w(title content)
     t = Topic.new
     assert t.invalid?
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
index 228c1c074f..e94d8ce88c 100644
--- a/activemodel/test/cases/validations_test.rb
+++ b/activemodel/test/cases/validations_test.rb
@@ -6,6 +6,9 @@ require 'models/reply'
 require 'models/custom_reader'
 require 'models/automobile'
 
+require 'active_support/json'
+require 'active_support/xml_mini'
+
 class ValidationsTest < ActiveModel::TestCase
 
   def setup
@@ -158,12 +161,18 @@ class ValidationsTest < ActiveModel::TestCase
     end
   end
 
-  def test_errors_to_xml
-    r = Reply.new :title => "Wrong Create"
-    assert r.invalid?
-    xml = r.errors.to_xml(:skip_instruct => true)
-    assert_equal "<errors>", xml.first(8)
-    assert xml.include?("<error>Content is Empty</error>")
+  def test_errors_conversions
+    Topic.validates_presence_of %w(title content)
+    t = Topic.new
+    assert t.invalid?
+
+    xml = t.errors.to_xml
+    assert_match %r{<errors>}, xml
+    assert_match %r{<error>Title can't be blank</error>}, xml
+    assert_match %r{<error>Content can't be blank</error>}, xml
+
+    json = t.errors.to_json
+    assert_equal t.errors.to_a.to_json, json
   end
 
   def test_validation_order
-- 
cgit v1.2.3


From 51be8dbdedd1279d74cd7a7e277c5042f278b8a2 Mon Sep 17 00:00:00 2001
From: Santiago Pastorino <santiago@wyeworks.com>
Date: Sat, 26 Jun 2010 15:40:14 -0300
Subject: Move constantize from conversions to inflections.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

This removes ActiveModel dependency on TZInfo.

[#4979 state:committed]

Signed-off-by: José Valim <jose.valim@gmail.com>
---
 activemodel/lib/active_model/observing.rb | 1 -
 1 file changed, 1 deletion(-)

(limited to 'activemodel')

diff --git a/activemodel/lib/active_model/observing.rb b/activemodel/lib/active_model/observing.rb
index 14f8bf72dc..d0f36ce3b1 100644
--- a/activemodel/lib/active_model/observing.rb
+++ b/activemodel/lib/active_model/observing.rb
@@ -2,7 +2,6 @@ require 'singleton'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/string/conversions'
 
 module ActiveModel
   module Observing
-- 
cgit v1.2.3