Merge commit 'mainstream/master'

50 files changed, 2723 insertions, 414 deletions

diff --git a/activemodel/Rakefile b/activemodel/Rakefile
index 544f49310a..ae2fbdb002 100755
--- a/activemodel/Rakefile
+++ b/activemodel/Rakefile
@@ -7,9 +7,8 @@ task :default => :test
 
 Rake::TestTask.new do |t| 
   t.libs << "test"
-  t.pattern = 'test/**/*_test.rb'
+  t.test_files = Dir.glob("test/cases/**/*_test.rb").sort
   t.verbose = true
-  t.warning = true
 end
 task :isolated_test do
   ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))
diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb
index 4ed7b0889d..803f5b0157 100644
--- a/activemodel/lib/active_model.rb
+++ b/activemodel/lib/active_model.rb
@@ -1,5 +1,41 @@
-require 'active_model/observing'
-# disabled until they're tested
-# require 'active_model/callbacks'
-# require 'active_model/validations'
-require 'active_model/base'
\ No newline at end of file
+#--
+# Copyright (c) 2004-2009 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+activesupport_path = "#{File.dirname(__FILE__)}/../../../activesupport/lib"
+$:.unshift(activesupport_path) if File.directory?(activesupport_path)
+require 'active_support'
+
+require 'active_support/inflector'
+
+module ActiveModel
+  autoload :Base, 'active_model/base'
+  autoload :Observing, 'active_model/observing'
+  autoload :Validations, 'active_model/validations'
+  autoload :Errors, 'active_model/errors'
+  autoload :DeprecatedErrorMethods, 'active_model/deprecated_error_methods'
+  autoload :TestCase, 'active_model/test_case'
+  autoload :StateMachine, 'active_model/state_machine'
+  autoload :ValidationsRepairHelper, 'active_model/validations_repair_helper'
+end
+
+I18n.load_path << File.dirname(__FILE__) + '/active_model/locale/en.yml'
diff --git a/activemodel/lib/active_model/callbacks.rb b/activemodel/lib/active_model/callbacks.rb
deleted file mode 100644
index c94f76109f..0000000000
--- a/activemodel/lib/active_model/callbacks.rb
+++ /dev/null
@@ -1,7 +0,0 @@
-require 'active_model/core'
-
-module ActiveModel
-  module Callbacks
-    
-  end
-end
\ No newline at end of file
diff --git a/activemodel/lib/active_model/core.rb b/activemodel/lib/active_model/core.rb
deleted file mode 100644
index 4201bcf158..0000000000
--- a/activemodel/lib/active_model/core.rb
+++ /dev/null
@@ -1,3 +0,0 @@
-activesupport_path = "#{File.dirname(__FILE__)}/../../../activesupport/lib"
-$:.unshift(activesupport_path) if File.directory?(activesupport_path)
-require 'active_support/inflector'
diff --git a/activemodel/lib/active_model/deprecated_error_methods.rb b/activemodel/lib/active_model/deprecated_error_methods.rb
index e0cbd9ba29..433de8931a 100644
--- a/activemodel/lib/active_model/deprecated_error_methods.rb
+++ b/activemodel/lib/active_model/deprecated_error_methods.rb
@@ -1,18 +1,18 @@
 module ActiveModel
   module DeprecatedErrorMethods
     def on(attribute)
-      ActiveSupport::Deprecation.warn "Errors#on have been deprecated, use Errors#[] instead"
-      self[attribute]
+      message = "Errors#on have been deprecated, use Errors#[] instead.\n"
+      message << "Also note that the behaviour of Errors#[] has changed. Errors#[] now always returns an Array. An empty Array is "
+      message << "returned when there are no errors on the specified attribute."
+      ActiveSupport::Deprecation.warn(message)
+
+      errors = self[attribute]
+      errors.size < 2 ? errors.first : errors
     end
 
     def on_base
       ActiveSupport::Deprecation.warn "Errors#on_base have been deprecated, use Errors#[:base] instead"
-      on(:base)
-    end
-
-    def add(attribute, msg = Errors.default_error_messages[:invalid])
-      ActiveSupport::Deprecation.warn "Errors#add(attribute, msg) has been deprecated, use Errors#[attribute] << msg instead"
-      self[attribute] << msg
+      ActiveSupport::Deprecation.silence { on(:base) }
     end
 
     def add_to_base(msg)
@@ -25,11 +25,6 @@ module ActiveModel
       self[attribute].any?
     end
 
-    def full_messages
-      ActiveSupport::Deprecation.warn "Errors#full_messages has been deprecated, use Errors#to_a instead"
-      to_a
-    end
-
     def each_full
       ActiveSupport::Deprecation.warn "Errors#each_full has been deprecated, use Errors#to_a.each instead"
       to_a.each { |error| yield error }
diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index bcf0810290..4be91d0505 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -1,40 +1,18 @@
 module ActiveModel
   class Errors < Hash
     include DeprecatedErrorMethods
-    
-    @@default_error_messages = {
-      :inclusion                => "is not included in the list",
-      :exclusion                => "is reserved",
-      :invalid                  => "is invalid",
-      :confirmation             => "doesn't match confirmation",
-      :accepted                 => "must be accepted",
-      :empty                    => "can't be empty",
-      :blank                    => "can't be blank",
-      :too_long                 => "is too long (maximum is %d characters)",
-      :too_short                => "is too short (minimum is %d characters)",
-      :wrong_length             => "is the wrong length (should be %d characters)",
-      :taken                    => "has already been taken",
-      :not_a_number             => "is not a number",
-      :greater_than             => "must be greater than %d",
-      :greater_than_or_equal_to => "must be greater than or equal to %d",
-      :equal_to                 => "must be equal to %d",
-      :less_than                => "must be less than %d",
-      :less_than_or_equal_to    => "must be less than or equal to %d",
-      :odd                      => "must be odd",
-      :even                     => "must be even"
-    }
-  
-    ##
-    # :singleton-method:
-    # Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
-    cattr_accessor :default_error_messages
+
+    def initialize(base)
+      @base = base
+      super()
+    end
 
     alias_method :get, :[]
     alias_method :set, :[]=
 
     def [](attribute)
       if errors = get(attribute.to_sym)
-        errors.size == 1 ? errors.first : errors
+        errors
       else
         set(attribute.to_sym, [])
       end
@@ -55,28 +33,126 @@ module ActiveModel
     end
 
     def to_a
-      inject([]) do |errors_with_attributes, (attribute, errors)|
-        if error.blank?
-          errors_with_attributes
-        else
-          if attr == :base
-            errors_with_attributes << error
-          else
-            errors_with_attributes << (attribute.to_s.humanize + " " + error)
-          end
-        end
-      end
+      full_messages
+    end
+
+    def count
+      to_a.size
     end
 
     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] ||= ::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
     end
+
+    # Adds an error message (+messsage+) to the +attribute+, which will be returned on a call to <tt>on(attribute)</tt>
+    # for the same attribute and ensure that this error object returns false when asked if <tt>empty?</tt>. More than one
+    # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
+    # If no +messsage+ is supplied, :invalid is assumed.
+    # If +message+ is a Symbol, it will be translated, using the appropriate scope (see translate_error).
+    def add(attribute, message = nil, options = {})
+      message ||= :invalid
+      message = generate_message(attribute, message, options) if message.is_a?(Symbol)
+      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)
+      [attributes].flatten.each do |attribute|
+        value = @base.get_attribute_value(attribute)
+        is_empty = value.respond_to?(:empty?) ? value.empty? : false
+        add(attribute, :empty, :default => custom_message) unless !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)
+      [attributes].flatten.each do |attribute|
+        value = @base.get_attribute_value(attribute)
+        add(attribute, :blank, :default => custom_message) if value.blank?
+      end
+    end
+
+    # Returns all the full error messages in an array.
+    #
+    #   class Company
+    #     validates_presence_of :name, :address, :email
+    #     validates_length_of :name, :in => 5..30
+    #   end
+    #
+    #   company = Company.create(:address => '123 First St.')
+    #   company.errors.full_messages # =>
+    #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Address can't be blank"]
+    def full_messages(options = {})
+      full_messages = []
+
+      each do |attribute, messages|
+        next if messages.empty?
+
+        if attribute == :base
+          messages.each {|m| full_messages << m }
+        else
+          attr_name = attribute.to_s.humanize
+          prefix = attr_name + I18n.t('activemodel.errors.format.separator', :default => ' ')
+          messages.each do |m|
+            full_messages <<  "#{prefix}#{m}"
+          end
+        end
+      end
+
+      full_messages
+    end
+
+    # Translates an error message in it's default scope (<tt>activemodel.errrors.messages</tt>).
+    # Error messages are first looked up in <tt>models.MODEL.attributes.ATTRIBUTE.MESSAGE</tt>, if it's not there, 
+    # it's looked up in <tt>models.MODEL.MESSAGE</tt> and if that is not there it returns the translation of the 
+    # default message (e.g. <tt>activemodel.errors.messages.MESSAGE</tt>). The translated model name, 
+    # translated attribute name and the value are available for interpolation.
+    #
+    # When using inheritence in your models, it will check all the inherited models too, but only if the model itself
+    # hasn't been found. Say you have <tt>class Admin < User; end</tt> and you wanted the translation for the <tt>:blank</tt>
+    # error +message+ for the <tt>title</tt> +attribute+, it looks for these translations:
+    # 
+    # <ol>
+    # <li><tt>activemodel.errors.models.admin.attributes.title.blank</tt></li>
+    # <li><tt>activemodel.errors.models.admin.blank</tt></li>
+    # <li><tt>activemodel.errors.models.user.attributes.title.blank</tt></li>
+    # <li><tt>activemodel.errors.models.user.blank</tt></li>
+    # <li><tt>activemodel.errors.messages.blank</tt></li>
+    # <li>any default you provided through the +options+ hash (in the activemodel.errors scope)</li>
+    # </ol>
+    def generate_message(attribute, message = :invalid, options = {})
+      message, options[:default] = options[:default], message if options[:default].is_a?(Symbol)
+
+      klass_ancestors = [@base.class]
+      klass_ancestors += @base.class.ancestors.reject {|x| x.is_a?(Module)}
+
+      defaults = klass_ancestors.map do |klass|
+        [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{message}", 
+          :"models.#{klass.name.underscore}.#{message}" ]
+      end
+
+      defaults << options.delete(:default)
+      defaults = defaults.compact.flatten << :"messages.#{message}"
+
+      key = defaults.shift
+      value = @base.get_attribute_value(attribute)
+
+      options = { :default => defaults,
+        :model => @base.class.name.humanize,
+        :attribute => attribute.to_s.humanize,
+        :value => value,
+        :scope => [:activemodel, :errors]
+      }.merge(options)
+
+      I18n.translate(key, options)
+    end
   end
 end
\ No newline at end of file
diff --git a/activemodel/lib/active_model/locale/en.yml b/activemodel/lib/active_model/locale/en.yml
new file mode 100644
index 0000000000..0c2cf9ea33
--- /dev/null
+++ b/activemodel/lib/active_model/locale/en.yml
@@ -0,0 +1,24 @@
+en:
+  activemodel:
+    errors:
+      # The values :model, :attribute and :value are always available for interpolation
+      # The value :count is available when applicable. Can be used for pluralization.
+      messages:
+        inclusion: "is not included in the list"
+        exclusion: "is reserved"
+        invalid: "is invalid"
+        confirmation: "doesn't match confirmation"
+        accepted: "must be accepted"
+        empty: "can't be empty"
+        blank: "can't be blank"
+        too_long: "is too long (maximum is {{count}} characters)"
+        too_short: "is too short (minimum is {{count}} characters)"
+        wrong_length: "is the wrong length (should be {{count}} characters)"
+        not_a_number: "is not a number"
+        greater_than: "must be greater than {{count}}"
+        greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+        equal_to: "must be equal to {{count}}"
+        less_than: "must be less than {{count}}"
+        less_than_or_equal_to: "must be less than or equal to {{count}}"
+        odd: "must be odd"
+        even: "must be even"
diff --git a/activemodel/lib/active_model/observing.rb b/activemodel/lib/active_model/observing.rb
index 9e99d7472c..d3c6d8e482 100644
--- a/activemodel/lib/active_model/observing.rb
+++ b/activemodel/lib/active_model/observing.rb
@@ -1,6 +1,5 @@
 require 'observer'
 require 'singleton'
-require 'active_model/core'
 
 module ActiveModel
   module Observing
diff --git a/activemodel/lib/active_model/state_machine.rb b/activemodel/lib/active_model/state_machine.rb
index bce90fd743..1172d31ea3 100644
--- a/activemodel/lib/active_model/state_machine.rb
+++ b/activemodel/lib/active_model/state_machine.rb
@@ -1,5 +1,10 @@
 module ActiveModel
   module StateMachine
+    autoload :Event, 'active_model/state_machine/event'
+    autoload :Machine, 'active_model/state_machine/machine'
+    autoload :State, 'active_model/state_machine/state'
+    autoload :StateTransition, 'active_model/state_machine/state_transition'
+
     class InvalidTransition < Exception
     end
 
diff --git a/activemodel/lib/active_model/test_case.rb b/activemodel/lib/active_model/test_case.rb
new file mode 100644
index 0000000000..4cb5c9cbc0
--- /dev/null
+++ b/activemodel/lib/active_model/test_case.rb
@@ -0,0 +1,18 @@
+require "active_support/test_case"
+
+module ActiveModel #:nodoc:
+  class TestCase < ActiveSupport::TestCase #:nodoc:
+    def with_kcode(kcode)
+      if RUBY_VERSION < '1.9'
+        orig_kcode, $KCODE = $KCODE, kcode
+        begin
+          yield
+        ensure
+          $KCODE = orig_kcode
+        end
+      else
+        yield
+      end
+    end
+  end
+end
diff --git a/activemodel/lib/active_model/validations.rb b/activemodel/lib/active_model/validations.rb
index 460d2d82e5..336c2757fc 100644
--- a/activemodel/lib/active_model/validations.rb
+++ b/activemodel/lib/active_model/validations.rb
@@ -1,16 +1,13 @@
-require 'active_model/core'
-
 module ActiveModel
   module Validations
-    def self.included(base) # :nodoc:
-      base.extend(ClassMethods)
-      base.__send__(:include, ActiveSupport::Callbacks)
-      base.define_callbacks :validate, :validate_on_create, :validate_on_update
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :validate
     end
 
     module ClassMethods
-      DEFAULT_VALIDATION_OPTIONS = { :on => :save, :allow_nil => false, :allow_blank => false, :message => nil }.freeze
-
       # Adds a validation method or block to the class. This is useful when
       # overriding the +validate+ instance method becomes too unwieldly and
       # you're looking for more descriptive declaration of your validations.
@@ -38,7 +35,7 @@ module ActiveModel
       #   end
       #
       # This usage applies to +validate_on_create+ and +validate_on_update as well+.
-      #
+
       # Validates each attribute against a block.
       #
       #   class Person < ActiveRecord::Base
@@ -48,7 +45,7 @@ module ActiveModel
       #   end
       #
       # Options:
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
       # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+.
       # * <tt>:allow_blank</tt> - Skip validation if attribute is blank.
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
@@ -62,9 +59,9 @@ module ActiveModel
         attrs   = attrs.flatten
 
         # Declare the validation.
-        send(validation_method(options[:on] || :save), options) do |record|
+        send(validation_method(options[:on]), options) do |record|
           attrs.each do |attr|
-            value = record.send(attr)
+            value = record.get_attribute_value(attr)
             next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
             yield record, attr, value
           end
@@ -72,50 +69,31 @@ module ActiveModel
       end
 
       private
-        def validation_method(on)
-          case on
-            when :save   then :validate
-            when :create then :validate_on_create
-            when :update then :validate_on_update
-          end
-        end
+
+      def validation_method(on)
+        :validate
+      end
     end
 
     # Returns the Errors object that holds all information about attribute error messages.
     def errors
-      @errors ||= Errors.new
+      @errors ||= Errors.new(self)
     end
 
     # Runs all the specified validations and returns true if no errors were added otherwise false.
     def valid?
       errors.clear
-
       run_callbacks(:validate)
-      
-      if responds_to?(:validate)
-        ActiveSupport::Deprecations.warn "Base#validate has been deprecated, please use Base.validate :method instead"
-        validate
-      end
-
-      if new_record?
-        run_callbacks(:validate_on_create)
-
-        if responds_to?(:validate_on_create)
-          ActiveSupport::Deprecations.warn(
-            "Base#validate_on_create has been deprecated, please use Base.validate_on_create :method instead")
-          validate_on_create
-        end
-      else
-        run_callbacks(:validate_on_update)
+      errors.empty?
+    end
 
-        if responds_to?(:validate_on_update)
-          ActiveSupport::Deprecations.warn(
-            "Base#validate_on_update has been deprecated, please use Base.validate_on_update :method instead")
-          validate_on_update
-        end
-      end
+    # Performs the opposite of <tt>valid?</tt>. Returns true if errors were added, false otherwise.
+    def invalid?
+      !valid?
+    end
 
-      errors.empty?
+    def get_attribute_value(attribute)
+      respond_to?(attribute.to_sym) ? send(attribute.to_sym) : instance_variable_get(:"@#{attribute}")
     end
   end
 end
@@ -123,4 +101,4 @@ end
 Dir[File.dirname(__FILE__) + "/validations/*.rb"].sort.each do |path|
   filename = File.basename(path)
   require "active_model/validations/#{filename}"
-end
\ No newline at end of file
+end
diff --git a/activemodel/lib/active_model/validations/acceptance.rb b/activemodel/lib/active_model/validations/acceptance.rb
index 9be7d51ffb..0c9ef51726 100644
--- a/activemodel/lib/active_model/validations/acceptance.rb
+++ b/activemodel/lib/active_model/validations/acceptance.rb
@@ -8,16 +8,16 @@ module ActiveModel
       #     validates_acceptance_of :eula, :message => "must be abided"
       #   end
       #
-      # If the database column does not exist, the <tt>:terms_of_service</tt> attribute is entirely virtual. This check is
-      # performed only if <tt>:terms_of_service</tt> is not +nil+ and by default on save.
+      # If the database column does not exist, the +terms_of_service+ attribute is entirely virtual. This check is
+      # performed only if +terms_of_service+ is not +nil+ and by default on save.
       #
       # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "must be accepted")
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
-      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+. (default is +true+)
+      # * <tt>:message</tt> - A custom error message (default is: "must be accepted").
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+      # * <tt>:allow_nil</tt> - Skip validation if attribute is +nil+ (default is true).
       # * <tt>:accept</tt> - Specifies value that is considered accepted.  The default value is a string "1", which
       #   makes it easy to relate to an HTML checkbox. This should be set to +true+ if you are validating a database
-      #   column, since the attribute is typecasted from "1" to +true+ before validation.
+      #   column, since the attribute is typecast from "1" to +true+ before validation.
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
@@ -25,19 +25,22 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_acceptance_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:accepted], :on => :save, :allow_nil => true, :accept => "1" }
+        configuration = { :allow_nil => true, :accept => "1" }
         configuration.update(attr_names.extract_options!)
 
         db_cols = begin
           column_names
-        rescue ActiveRecord::StatementInvalid
+        rescue Exception # To ignore both statement and connection errors
           []
         end
+
         names = attr_names.reject { |name| db_cols.include?(name.to_s) }
         attr_accessor(*names)
 
         validates_each(attr_names,configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
+          unless value == configuration[:accept]
+            record.errors.add(attr_name, :accepted, :default => configuration[:message]) 
+          end
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/associated.rb b/activemodel/lib/active_model/validations/associated.rb
deleted file mode 100644
index b2d78af580..0000000000
--- a/activemodel/lib/active_model/validations/associated.rb
+++ /dev/null
@@ -1,46 +0,0 @@
-module ActiveModel
-  module Validations
-    module ClassMethods
-      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
-      #
-      #   class Book < ActiveRecord::Base
-      #     has_many :pages
-      #     belongs_to :library
-      #
-      #     validates_associated :pages, :library
-      #   end
-      #
-      # Warning: If, after the above definition, you then wrote:
-      #
-      #   class Page < ActiveRecord::Base
-      #     belongs_to :book
-      #
-      #     validates_associated :book
-      #   end
-      #
-      # ...this would specify a circular dependency and cause infinite recursion.
-      #
-      # NOTE: This validation will not fail if the association hasn't been assigned. If you want to ensure that the association
-      # is both present and guaranteed to be valid, you also need to use +validates_presence_of+.
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "is invalid")
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_associated(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save }
-        configuration.update(attr_names.extract_options!)
-
-        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) { |v, r| (r.nil? || r.valid?) && v }
-        end
-      end
-    end
-  end
-end
\ No newline at end of file
diff --git a/activemodel/lib/active_model/validations/confirmation.rb b/activemodel/lib/active_model/validations/confirmation.rb
index ba4a18adb7..b9823172f7 100644
--- a/activemodel/lib/active_model/validations/confirmation.rb
+++ b/activemodel/lib/active_model/validations/confirmation.rb
@@ -21,8 +21,8 @@ module ActiveModel
       #   validates_presence_of :password_confirmation, :if => :password_changed?
       #
       # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "doesn't match confirmation")
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
+      # * <tt>:message</tt> - A custom error message (default is: "doesn't match confirmation").
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
@@ -30,13 +30,14 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_confirmation_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:confirmation], :on => :save }
-        configuration.update(attr_names.extract_options!)
+        configuration = attr_names.extract_options!
 
         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")
+          unless record.send("#{attr_name}_confirmation").nil? or value == record.send("#{attr_name}_confirmation")
+            record.errors.add(attr_name, :confirmation, :default => configuration[:message]) 
+          end
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/exclusion.rb b/activemodel/lib/active_model/validations/exclusion.rb
index 1592000fc7..0aa9848ee1 100644
--- a/activemodel/lib/active_model/validations/exclusion.rb
+++ b/activemodel/lib/active_model/validations/exclusion.rb
@@ -6,14 +6,14 @@ module ActiveModel
       #   class Person < ActiveRecord::Base
       #     validates_exclusion_of :username, :in => %w( admin superuser ), :message => "You don't belong here"
       #     validates_exclusion_of :age, :in => 30..60, :message => "This site is only for under 30 and over 60"
-      #     validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension %s is not allowed"
+      #     validates_exclusion_of :format, :in => %w( mov avi ), :message => "extension {{value}} is not allowed"
       #   end
       #
       # Configuration options:
-      # * <tt>:in</tt> - An enumerable object of items that the value shouldn't be part of
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "is reserved")
-      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
-      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
+      # * <tt>:in</tt> - An enumerable object of items that the value shouldn't be part of.
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is reserved").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
@@ -21,15 +21,16 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_exclusion_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:exclusion], :on => :save }
-        configuration.update(attr_names.extract_options!)
+        configuration = attr_names.extract_options!
 
         enum = configuration[:in] || configuration[:within]
 
         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?)
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message] % value) if enum.include?(value)
+          if enum.include?(value)
+            record.errors.add(attr_name, :exclusion, :default => configuration[:message], :value => value) 
+          end
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/format.rb b/activemodel/lib/active_model/validations/format.rb
index 1320ef646a..8efce8ba2b 100644
--- a/activemodel/lib/active_model/validations/format.rb
+++ b/activemodel/lib/active_model/validations/format.rb
@@ -13,11 +13,11 @@ module ActiveModel
       # A regular expression must be provided or else an exception will be raised.
       #
       # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "is invalid")
-      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
-      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
-      # * <tt>:with</tt> - The regular expression used to validate the format with (note: must be supplied!)
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
+      # * <tt>:message</tt> - A custom error message (default is: "is invalid").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
+      # * <tt>:with</tt> - The regular expression used to validate the format with (note: must be supplied!).
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
@@ -25,13 +25,15 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_format_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:invalid], :on => :save, :with => nil }
+        configuration = { :with => nil }
         configuration.update(attr_names.extract_options!)
 
         raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash") unless configuration[:with].is_a?(Regexp)
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message]) unless value.to_s =~ configuration[:with]
+          unless value.to_s =~ configuration[:with]
+            record.errors.add(attr_name, :invalid, :default => configuration[:message], :value => value) 
+          end
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/inclusion.rb b/activemodel/lib/active_model/validations/inclusion.rb
index f288810d90..a4bc8fe035 100644
--- a/activemodel/lib/active_model/validations/inclusion.rb
+++ b/activemodel/lib/active_model/validations/inclusion.rb
@@ -6,14 +6,14 @@ module ActiveModel
       #   class Person < ActiveRecord::Base
       #     validates_inclusion_of :gender, :in => %w( m f )
       #     validates_inclusion_of :age, :in => 0..99
-      #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension %s is not included in the list"
+      #     validates_inclusion_of :format, :in => %w( jpg gif png ), :message => "extension {{value}} is not included in the list"
       #   end
       #
       # Configuration options:
-      # * <tt>:in</tt> - An enumerable object of available items
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "is not included in the list")
-      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is null (default is: +false+)
-      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
+      # * <tt>:in</tt> - An enumerable object of available items.
+      # * <tt>:message</tt> - Specifies a custom error message (default is: "is not included in the list").
+      # * <tt>:allow_nil</tt> - If set to true, skips this validation if the attribute is +nil+ (default is +false+).
+      # * <tt>:allow_blank</tt> - If set to true, skips this validation if the attribute is blank (default is +false+).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
@@ -21,15 +21,16 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_inclusion_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:inclusion], :on => :save }
-        configuration.update(attr_names.extract_options!)
+        configuration = attr_names.extract_options!
 
         enum = configuration[:in] || configuration[:within]
 
         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?)
 
         validates_each(attr_names, configuration) do |record, attr_name, value|
-          record.errors.add(attr_name, configuration[:message] % value) unless enum.include?(value)
+          unless enum.include?(value)
+            record.errors.add(attr_name, :inclusion, :default => configuration[:message], :value => value) 
+          end
         end
       end
     end
diff --git a/activemodel/lib/active_model/validations/length.rb b/activemodel/lib/active_model/validations/length.rb
index 673ad33974..bb9a269a02 100644
--- a/activemodel/lib/active_model/validations/length.rb
+++ b/activemodel/lib/active_model/validations/length.rb
@@ -2,90 +2,88 @@ module ActiveModel
   module Validations
     module ClassMethods
       ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
-    
+
       # Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
       #
       #   class Person < ActiveRecord::Base
-      #     validates_length_of :first_name, :maximum => 30
-      #     validates_length_of :last_name, :maximum => 30, :message => "less than %d if you don't mind"
+      #     validates_length_of :first_name, :maximum=>30
+      #     validates_length_of :last_name, :maximum=>30, :message=>"less than {{count}} if you don't mind"
       #     validates_length_of :fax, :in => 7..32, :allow_nil => true
       #     validates_length_of :phone, :in => 7..32, :allow_blank => true
       #     validates_length_of :user_name, :within => 6..20, :too_long => "pick a shorter name", :too_short => "pick a longer name"
-      #     validates_length_of :fav_bra_size, :minimum => 1, :too_short => "please enter at least %d character"
-      #     validates_length_of :smurf_leader, :is => 4, :message => "papa is spelled with %d characters... don't play me."
+      #     validates_length_of :fav_bra_size, :minimum => 1, :too_short => "please enter at least {{count}} character"
+      #     validates_length_of :smurf_leader, :is => 4, :message => "papa is spelled with {{count}} characters... don't play me."
+      #     validates_length_of :essay, :minimum => 100, :too_short => "Your essay must be at least {{count}} words."), :tokenizer => lambda {|str| str.scan(/\w+/) }
       #   end
       #
       # Configuration options:
-      # * <tt>:minimum</tt> - The minimum size of the attribute
-      # * <tt>:maximum</tt> - The maximum size of the attribute
-      # * <tt>:is</tt> - The exact size of the attribute
-      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute
-      # * <tt>:in</tt> - A synonym (or alias) for <tt>:within</tt>
+      # * <tt>:minimum</tt> - The minimum size of the attribute.
+      # * <tt>:maximum</tt> - The maximum size of the attribute.
+      # * <tt>:is</tt> - The exact size of the attribute.
+      # * <tt>:within</tt> - A range specifying the minimum and maximum size of the attribute.
+      # * <tt>:in</tt> - A synonym(or alias) for <tt>:within</tt>.
       # * <tt>:allow_nil</tt> - Attribute may be +nil+; skip validation.
       # * <tt>:allow_blank</tt> - Attribute may be blank; skip validation.
-      # * <tt>:too_long</tt> - The error message if the attribute goes over the maximum (default is: "is too long (maximum is %d characters)")
-      # * <tt>:too_short</tt> - The error message if the attribute goes under the minimum (default is: "is too short (min is %d characters)")
-      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method and the attribute is the wrong size (default is: "is the wrong length (should be %d characters)")
-      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>, <tt>:maximum</tt>, or <tt>:is</tt> violation.  An alias of the appropriate <tt>:too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
+      # * <tt>:too_long</tt> - The error message if the attribute goes over the maximum (default is: "is too long (maximum is {{count}} characters)").
+      # * <tt>:too_short</tt> - The error message if the attribute goes under the minimum (default is: "is too short (min is {{count}} characters)").
+      # * <tt>:wrong_length</tt> - The error message if using the <tt>:is</tt> method and the attribute is the wrong size (default is: "is the wrong length (should be {{count}} characters)").
+      # * <tt>:message</tt> - The error message to use for a <tt>:minimum</tt>, <tt>:maximum</tt>, or <tt>:is</tt> violation.  An alias of the appropriate <tt>too_long</tt>/<tt>too_short</tt>/<tt>wrong_length</tt> message.
+      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
       # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
+      # * <tt>:tokenizer</tt> - Specifies how to split up the attribute string. (e.g. <tt>:tokenizer => lambda {|str| str.scan(/\w+/)}</tt> to
+      #   count words as in above example.)
+      #   Defaults to <tt>lambda{ |value| value.split(//) }</tt> which counts individual characters.
       def validates_length_of(*attrs)
         # Merge given options with defaults.
-        options = {
-          :too_long     => ActiveRecord::Errors.default_error_messages[:too_long],
-          :too_short    => ActiveRecord::Errors.default_error_messages[:too_short],
-          :wrong_length => ActiveRecord::Errors.default_error_messages[:wrong_length]
-        }.merge(DEFAULT_VALIDATION_OPTIONS)
+        options = { :tokenizer => lambda {|value| value.split(//)} }
         options.update(attrs.extract_options!.symbolize_keys)
 
         # Ensure that one and only one range option is specified.
         range_options = ALL_RANGE_OPTIONS & options.keys
         case range_options.size
-          when 0
-            raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
-          when 1
-            # Valid number of options; do nothing.
-          else
-            raise ArgumentError, 'Too many range options specified.  Choose only one.'
+        when 0
+          raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
+        when 1
+          # Valid number of options; do nothing.
+        else
+          raise ArgumentError, 'Too many range options specified.  Choose only one.'
         end
 
         # Get range option and value.
         option = range_options.first
         option_value = options[range_options.first]
+        key = {:is => :wrong_length, :minimum => :too_short, :maximum => :too_long}[option]
+        custom_message = options[:message] || options[key]
 
         case option
-          when :within, :in
-            raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
-
-            too_short = options[:too_short] % option_value.begin
-            too_long  = options[:too_long]  % option_value.end
+        when :within, :in
+          raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)
 
-            validates_each(attrs, options) do |record, attr, value|
-              value = value.split(//) if value.kind_of?(String)
-              if value.nil? or value.size < option_value.begin
-                record.errors.add(attr, too_short)
-              elsif value.size > option_value.end
-                record.errors.add(attr, too_long)
-              end
+          validates_each(attrs, options) do |record, attr, value|
+            value = options[:tokenizer].call(value) if value.kind_of?(String)
+            if value.nil? or value.size < option_value.begin
+              record.errors.add(attr, :too_short, :default => custom_message || options[:too_short], :count => option_value.begin)
+            elsif value.size > option_value.end
+              record.errors.add(attr, :too_long, :default => custom_message || options[:too_long], :count => option_value.end)
             end
-          when :is, :minimum, :maximum
-            raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0
-
-            # Declare different validations per option.
-            validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
-            message_options = { :is => :wrong_length, :minimum => :too_short, :maximum => :too_long }
+          end
+        when :is, :minimum, :maximum
+          raise ArgumentError, ":#{option} must be a nonnegative Integer" unless option_value.is_a?(Integer) and option_value >= 0
 
-            message = (options[:message] || options[message_options[option]]) % option_value
+          # Declare different validations per option.
+          validity_checks = { :is => "==", :minimum => ">=", :maximum => "<=" }
 
-            validates_each(attrs, options) do |record, attr, value|
-              value = value.split(//) if value.kind_of?(String)
-              record.errors.add(attr, message) unless !value.nil? and value.size.method(validity_checks[option])[option_value]
+          validates_each(attrs, options) do |record, attr, value|
+            value = options[:tokenizer].call(value) if value.kind_of?(String)
+            unless !value.nil? and value.size.method(validity_checks[option])[option_value]
+              record.errors.add(attr, key, :default => custom_message, :count => option_value) 
             end
+          end
         end
       end
 
diff --git a/activemodel/lib/active_model/validations/numericality.rb b/activemodel/lib/active_model/validations/numericality.rb
index 92ca5f4082..79fca2f1ea 100644
--- a/activemodel/lib/active_model/validations/numericality.rb
+++ b/activemodel/lib/active_model/validations/numericality.rb
@@ -5,10 +5,9 @@ module ActiveModel
                                   :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
                                   :odd => 'odd?', :even => 'even?' }.freeze
 
-
       # Validates whether the value of the specified attribute is numeric by trying to convert it to
-      # a float with Kernel.Float (if <tt>integer</tt> is false) or applying it to the regular expression
-      # <tt>/\A[\+\-]?\d+\Z/</tt> (if <tt>integer</tt> is true).
+      # a float with Kernel.Float (if <tt>only_integer</tt> is false) or applying it to the regular expression
+      # <tt>/\A[\+\-]?\d+\Z/</tt> (if <tt>only_integer</tt> is set to true).
       #
       #   class Person < ActiveRecord::Base
       #     validates_numericality_of :value, :on => :create
@@ -33,10 +32,9 @@ module ActiveModel
       #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
       #   method, proc or string should return or evaluate to a true or false value.
       def validates_numericality_of(*attr_names)
-        configuration = { :on => :save, :only_integer => false, :allow_nil => false }
+        configuration = { :only_integer => false, :allow_nil => false }
         configuration.update(attr_names.extract_options!)
 
-
         numericality_options = ALL_NUMERICALITY_CHECKS.keys & configuration.keys
 
         (numericality_options - [ :odd, :even ]).each do |option|
@@ -44,33 +42,41 @@ module ActiveModel
         end
 
         validates_each(attr_names,configuration) do |record, attr_name, value|
-          raw_value = record.send("#{attr_name}_before_type_cast") || value
+          before_type_cast = "#{attr_name}_before_type_cast"
+
+          if record.respond_to?(before_type_cast.to_sym)
+            raw_value = record.send("#{attr_name}_before_type_cast") || value
+          else
+            raw_value = value
+          end
 
           next if configuration[:allow_nil] and raw_value.nil?
 
           if configuration[:only_integer]
             unless raw_value.to_s =~ /\A[+-]?\d+\Z/
-              record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[:not_a_number])
+              record.errors.add(attr_name, :not_a_number, :value => raw_value, :default => configuration[:message])
               next
             end
             raw_value = raw_value.to_i
           else
-           begin
-              raw_value = Kernel.Float(raw_value.to_s)
+            begin
+              raw_value = Kernel.Float(raw_value)
             rescue ArgumentError, TypeError
-              record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[:not_a_number])
+              record.errors.add(attr_name, :not_a_number, :value => raw_value, :default => configuration[:message])
               next
             end
           end
 
           numericality_options.each do |option|
             case option
-              when :odd, :even
-                record.errors.add(attr_name, configuration[:message] || ActiveRecord::Errors.default_error_messages[option]) unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
-              else
-                message = configuration[:message] || ActiveRecord::Errors.default_error_messages[option]
-                message = message % configuration[option] if configuration[option]
-                record.errors.add(attr_name, message) unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]
+            when :odd, :even
+              unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
+                record.errors.add(attr_name, option, :value => raw_value, :default => configuration[:message]) 
+              end
+            else
+              unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]
+                record.errors.add(attr_name, option, :default => configuration[:message], :value => raw_value, :count => configuration[option])
+              end
             end
           end
         end
diff --git a/activemodel/lib/active_model/validations/presence.rb b/activemodel/lib/active_model/validations/presence.rb
index 62e466901b..518bc8a952 100644
--- a/activemodel/lib/active_model/validations/presence.rb
+++ b/activemodel/lib/active_model/validations/presence.rb
@@ -7,29 +7,26 @@ module ActiveModel
       #     validates_presence_of :first_name
       #   end
       #
-      # The +first_name+ attribute must be in the object and it cannot be blank.
+      # The first_name attribute must be in the object and it cannot be blank.
       #
-      # If you want to validate the presence of a boolean field (where the real values are +true+ and +false+),
-      # you will want to use
+      # If you want to validate the presence of a boolean field (where the real values are true and false),
+      # you will want to use <tt>validates_inclusion_of :field_name, :in => [true, false]</tt>.
       #
-      #   validates_inclusion_of :field_name, :in => [true, false]
-      #
-      # This is due to the way Object#blank? handles boolean values:
-      #
-      #   false.blank? # => true
+      # This is due to the way Object#blank? handles boolean values: <tt>false.blank? # => true</tt>.
       #
       # Configuration options:
-      # * <tt>:message</tt> - A custom error message (default is: "can't be blank")
-      # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
+      # * <tt>message</tt> - A custom error message (default is: "can't be blank").
+      # * <tt>on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, 
+      #   <tt>:update</tt>).
+      # * <tt>if</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a true or false value.
+      # * <tt>unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).
+      #   The method, proc or string should return or evaluate to a true or false value.
+      #
       def validates_presence_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:blank], :on => :save }
-        configuration.update(attr_names.extract_options!)
+        configuration = attr_names.extract_options!
 
         # can't use validates_each here, because it cannot cope with nonexistent attributes,
         # while errors.add_on_empty can
diff --git a/activemodel/lib/active_model/validations/uniqueness.rb b/activemodel/lib/active_model/validations/uniqueness.rb
deleted file mode 100644
index 593d2cfd54..0000000000
--- a/activemodel/lib/active_model/validations/uniqueness.rb
+++ /dev/null
@@ -1,104 +0,0 @@
-module ActiveModel
-  module Validations
-    module ClassMethods
-      # Validates whether the value of the specified attributes are unique across the system. Useful for making sure that only one user
-      # can be named "davidhh".
-      #
-      #   class Person < ActiveRecord::Base
-      #     validates_uniqueness_of :user_name, :scope => :account_id
-      #   end
-      #
-      # It can also validate whether the value of the specified attributes are unique based on multiple scope parameters.  For example,
-      # making sure that a teacher can only be on the schedule once per semester for a particular class.
-      #
-      #   class TeacherSchedule < ActiveRecord::Base
-      #     validates_uniqueness_of :teacher_id, :scope => [:semester_id, :class_id]
-      #   end
-      #
-      # When the record is created, a check is performed to make sure that no record exists in the database with the given value for the specified
-      # attribute (that maps to a column). When the record is updated, the same check is made but disregarding the record itself.
-      #
-      # Because this check is performed outside the database there is still a chance that duplicate values
-      # will be inserted in two parallel transactions.  To guarantee against this you should create a 
-      # unique index on the field. See +add_index+ for more information.
-      #
-      # Configuration options:
-      # * <tt>:message</tt> - Specifies a custom error message (default is: "has already been taken")
-      # * <tt>:scope</tt> - One or more columns by which to limit the scope of the uniqueness constraint.
-      # * <tt>:case_sensitive</tt> - Looks for an exact match.  Ignored by non-text columns (+true+ by default).
-      # * <tt>:allow_nil</tt> - If set to +true+, skips this validation if the attribute is +nil+ (default is: +false+)
-      # * <tt>:allow_blank</tt> - If set to +true+, skips this validation if the attribute is blank (default is: +false+)
-      # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
-      #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_uniqueness_of(*attr_names)
-        configuration = { :message => ActiveRecord::Errors.default_error_messages[:taken] }
-        configuration.update(attr_names.extract_options!)
-
-        validates_each(attr_names,configuration) do |record, attr_name, value|
-          # The check for an existing value should be run from a class that
-          # isn't abstract. This means working down from the current class
-          # (self), to the first non-abstract class. Since classes don't know
-          # their subclasses, we have to build the hierarchy between self and
-          # the record's class.
-          class_hierarchy = [record.class]
-          while class_hierarchy.first != self
-            class_hierarchy.insert(0, class_hierarchy.first.superclass)
-          end
-
-          # Now we can work our way down the tree to the first non-abstract
-          # class (which has a database table to query from).
-          finder_class = class_hierarchy.detect { |klass| !klass.abstract_class? }
-
-          if value.nil? || (configuration[:case_sensitive] || !finder_class.columns_hash[attr_name.to_s].text?)
-            condition_sql = "#{record.class.quoted_table_name}.#{attr_name} #{attribute_condition(value)}"
-            condition_params = [value]
-          else
-            # sqlite has case sensitive SELECT query, while MySQL/Postgresql don't.
-            # Hence, this is needed only for sqlite.
-            condition_sql = "LOWER(#{record.class.quoted_table_name}.#{attr_name}) #{attribute_condition(value)}"
-            condition_params = [value.downcase]
-          end
-
-          if scope = configuration[:scope]
-            Array(scope).map do |scope_item|
-              scope_value = record.send(scope_item)
-              condition_sql << " AND #{record.class.quoted_table_name}.#{scope_item} #{attribute_condition(scope_value)}"
-              condition_params << scope_value
-            end
-          end
-
-          unless record.new_record?
-            condition_sql << " AND #{record.class.quoted_table_name}.#{record.class.primary_key} <> ?"
-            condition_params << record.send(:id)
-          end
-
-          results = finder_class.with_exclusive_scope do
-            connection.select_all(
-              construct_finder_sql(
-                :select     => attr_name,
-                :from       => finder_class.quoted_table_name,
-                :conditions => [condition_sql, *condition_params]
-              )
-            )
-          end
-
-          unless results.length.zero?
-            found = true
-
-            # As MySQL/Postgres don't have case sensitive SELECT queries, we try to find duplicate
-            # column in ruby when case sensitive option
-            if configuration[:case_sensitive] && finder_class.columns_hash[attr_name.to_s].text?
-              found = results.any? { |a| a[attr_name.to_s] == value }
-            end
-
-            record.errors.add(attr_name, configuration[:message]) if found
-          end
-        end
-      end
-    end
-  end
-end
diff --git a/activemodel/lib/active_model/validations_repair_helper.rb b/activemodel/lib/active_model/validations_repair_helper.rb
new file mode 100644
index 0000000000..432e411308
--- /dev/null
+++ b/activemodel/lib/active_model/validations_repair_helper.rb
@@ -0,0 +1,44 @@
+module ActiveModel
+  module ValidationsRepairHelper
+    extend ActiveSupport::Concern
+
+    module Toolbox
+      def self.record_validations(*model_classes)
+        model_classes.inject({}) do |repair, klass|
+          repair[klass] ||= {}
+          [:validate, :validate_on_create, :validate_on_update].each do |callback|
+            the_callback = klass.instance_variable_get("@#{callback.to_s}_callbacks")
+            repair[klass][callback] = (the_callback.nil? ? nil : the_callback.dup)
+          end
+          repair
+        end
+      end
+
+      def self.reset_validations(recorded)
+        recorded.each do |klass, repairs|
+          [:validate, :validate_on_create, :validate_on_update].each do |callback|
+            klass.instance_variable_set("@#{callback.to_s}_callbacks", repairs[callback])
+          end
+        end
+      end
+    end
+
+    module ClassMethods
+      def repair_validations(*model_classes)
+        setup do
+          @validation_repairs = Toolbox.record_validations(*model_classes)
+        end
+        teardown do
+          Toolbox.reset_validations(@validation_repairs)
+        end
+      end
+    end
+
+    def repair_validations(*model_classes, &block)
+      validation_repairs = Toolbox.record_validations(*model_classes)
+      return block.call
+    ensure
+      Toolbox.reset_validations(validation_repairs)
+    end
+  end
+end
diff --git a/activemodel/test/cases/helper.rb b/activemodel/test/cases/helper.rb
new file mode 100644
index 0000000000..f023109a60
--- /dev/null
+++ b/activemodel/test/cases/helper.rb
@@ -0,0 +1,20 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+$:.unshift(File.dirname(__FILE__) + '/../../../activesupport/lib')
+
+require 'config'
+
+require 'active_model'
+
+# Show backtraces for deprecated behavior for quicker cleanup.
+ActiveSupport::Deprecation.debug = true
+
+require 'rubygems'
+require 'test/unit'
+gem 'mocha', '>= 0.9.5'
+require 'mocha'
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end
diff --git a/activemodel/test/observing_test.rb b/activemodel/test/cases/observing_test.rb
index dc41c9f881..421ac4b4f8 100644
--- a/activemodel/test/observing_test.rb
+++ b/activemodel/test/cases/observing_test.rb
@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'cases/helper'
 
 class ObservedModel < ActiveModel::Base
   class Observer
diff --git a/activemodel/test/state_machine/event_test.rb b/activemodel/test/cases/state_machine/event_test.rb
index 05e7c78e8a..2a0ef53a3f 100644
--- a/activemodel/test/state_machine/event_test.rb
+++ b/activemodel/test/cases/state_machine/event_test.rb
@@ -1,5 +1,4 @@
-require 'test_helper'
-require 'active_model/state_machine/event'
+require 'cases/helper'
 
 class EventTest < ActiveModel::TestCase
   def setup
diff --git a/activemodel/test/state_machine/machine_test.rb b/activemodel/test/cases/state_machine/machine_test.rb
index d23c223160..2aa954d80c 100644
--- a/activemodel/test/state_machine/machine_test.rb
+++ b/activemodel/test/cases/state_machine/machine_test.rb
@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'cases/helper'
 
 class MachineTestSubject
   include ActiveModel::StateMachine
diff --git a/activemodel/test/state_machine/state_test.rb b/activemodel/test/cases/state_machine/state_test.rb
index fbf9ce7b0a..527bfd4c04 100644
--- a/activemodel/test/state_machine/state_test.rb
+++ b/activemodel/test/cases/state_machine/state_test.rb
@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'cases/helper'
 
 class StateTestSubject
   include ActiveModel::StateMachine
diff --git a/activemodel/test/state_machine/state_transition_test.rb b/activemodel/test/cases/state_machine/state_transition_test.rb
index 966396fab1..17f9d88be7 100644
--- a/activemodel/test/state_machine/state_transition_test.rb
+++ b/activemodel/test/cases/state_machine/state_transition_test.rb
@@ -1,5 +1,4 @@
-require 'test_helper'
-require 'active_model/state_machine/state_transition'
+require 'cases/helper'
 
 class StateTransitionTest < ActiveModel::TestCase
   test 'should set from, to, and opts attr readers' do
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/cases/state_machine_test.rb
index 312d8728ba..f66299741e 100644
--- a/activemodel/test/state_machine_test.rb
+++ b/activemodel/test/cases/state_machine_test.rb
@@ -1,4 +1,4 @@
-require 'test_helper'
+require 'cases/helper'
 
 class StateMachineSubject
   include ActiveModel::StateMachine
diff --git a/activemodel/test/cases/tests_database.rb b/activemodel/test/cases/tests_database.rb
new file mode 100644
index 0000000000..0f4475fa2d
--- /dev/null
+++ b/activemodel/test/cases/tests_database.rb
@@ -0,0 +1,41 @@
+require 'logger'
+
+$:.unshift(File.dirname(__FILE__) + '/../../../activerecord/lib')
+require 'active_record'
+require 'active_record/fixtures'
+
+module ActiveModel
+  module TestsDatabase
+    mattr_accessor :connected
+
+    def self.included(base)
+      unless self.connected
+        setup_connection
+        setup_schema
+      end
+
+      base.send :include, ActiveRecord::TestFixtures
+    end
+
+    def self.setup_schema
+      original, $stdout = $stdout, StringIO.new
+      load(SCHEMA_FILE)
+    ensure
+      $stdout = original
+      self.connected = true
+    end
+
+    def self.setup_connection
+      defaults = { :database => ':memory:' }
+      begin
+        adapter = defined?(JRUBY_VERSION) ? 'jdbcsqlite3' : 'sqlite3'
+        options = defaults.merge :adapter => adapter, :timeout => 500
+        ActiveRecord::Base.establish_connection(options)
+      rescue Exception
+        $stderr.puts 'SQLite 3 unavailable; trying SQLite 2.'
+        options = defaults.merge :adapter => 'sqlite'
+        ActiveRecord::Base.establish_connection(options)
+      end
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/acceptance_validation_test.rb b/activemodel/test/cases/validations/acceptance_validation_test.rb
new file mode 100644
index 0000000000..88e5fdb358
--- /dev/null
+++ b/activemodel/test/cases/validations/acceptance_validation_test.rb
@@ -0,0 +1,80 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/reply'
+require 'models/developer'
+require 'models/person'
+
+class AcceptanceValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_terms_of_service_agreement_no_acceptance
+    Topic.validates_acceptance_of(:terms_of_service, :on => :create)
+
+    t = Topic.create("title" => "We should not be confirmed")
+    assert t.save
+  end
+
+  def test_terms_of_service_agreement
+    Topic.validates_acceptance_of(:terms_of_service, :on => :create)
+
+    t = Topic.create("title" => "We should be confirmed","terms_of_service" => "")
+    assert !t.save
+    assert_equal ["must be accepted"], t.errors[:terms_of_service]
+
+    t.terms_of_service = "1"
+    assert t.save
+  end
+
+  def test_eula
+    Topic.validates_acceptance_of(:eula, :message => "must be abided", :on => :create)
+
+    t = Topic.create("title" => "We should be confirmed","eula" => "")
+    assert !t.save
+    assert_equal ["must be abided"], t.errors[:eula]
+
+    t.eula = "1"
+    assert t.save
+  end
+
+  def test_terms_of_service_agreement_with_accept_value
+    Topic.validates_acceptance_of(:terms_of_service, :on => :create, :accept => "I agree.")
+
+    t = Topic.create("title" => "We should be confirmed", "terms_of_service" => "")
+    assert !t.save
+    assert_equal ["must be accepted"], t.errors[:terms_of_service]
+
+    t.terms_of_service = "I agree."
+    assert t.save
+  end
+
+  def test_validates_acceptance_of_with_custom_error_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_acceptance_of :salary, :message=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.salary = "0"
+      assert !d.valid?
+      assert_equal "This string contains 'single' and \"double\" quotes", d.errors[:salary].last
+    end
+  end
+
+  def test_validates_acceptance_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_acceptance_of :karma
+
+      p = Person.new
+      p.karma = ""
+
+      assert p.invalid?
+      assert_equal ["must be accepted"], p.errors[:karma]
+
+      p.karma = "1"
+      assert p.valid?
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/conditional_validation_test.rb b/activemodel/test/cases/validations/conditional_validation_test.rb
new file mode 100644
index 0000000000..4c716d5d48
--- /dev/null
+++ b/activemodel/test/cases/validations/conditional_validation_test.rb
@@ -0,0 +1,140 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+
+class ConditionalValidationTest < ActiveModel::TestCase
+ include ActiveModel::TestsDatabase
+ include ActiveModel::ValidationsRepairHelper
+
+ repair_validations(Topic)
+  
+  def test_if_validation_using_method_true
+    # When the method returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => :condition_is_true )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_unless_validation_using_method_true
+    # When the method returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => :condition_is_true )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert !t.errors[:title].any?
+  end
+
+  def test_if_validation_using_method_false
+    # When the method returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => :condition_is_true_but_its_not )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert t.errors[:title].empty?
+  end
+
+  def test_unless_validation_using_method_false
+    # When the method returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => :condition_is_true_but_its_not )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_if_validation_using_string_true
+    # When the evaluated string returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => "a = 1; a == 1" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_unless_validation_using_string_true
+    # When the evaluated string returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => "a = 1; a == 1" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert t.errors[:title].empty?
+  end
+
+  def test_if_validation_using_string_false
+    # When the evaluated string returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :if => "false")
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert t.errors[:title].empty?
+  end
+
+  def test_unless_validation_using_string_false
+    # When the evaluated string returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}", :unless => "false")
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_if_validation_using_block_true
+    # When the block returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+      :if => Proc.new { |r| r.content.size > 4 } )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_unless_validation_using_block_true
+    # When the block returns true
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+      :unless => Proc.new { |r| r.content.size > 4 } )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert t.errors[:title].empty?
+  end
+
+  def test_if_validation_using_block_false
+    # When the block returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+      :if => Proc.new { |r| r.title != "uhohuhoh"} )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert t.valid?
+    assert t.errors[:title].empty?
+  end
+
+  def test_unless_validation_using_block_false
+    # When the block returns false
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}",
+      :unless => Proc.new { |r| r.title != "uhohuhoh"} )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  # previous implementation of validates_presence_of eval'd the
+  # string with the wrong binding, this regression test is to
+  # ensure that it works correctly
+  def test_validation_with_if_as_string
+    Topic.validates_presence_of(:title)
+    Topic.validates_presence_of(:author_name, :if => "title.to_s.match('important')")
+
+    t = Topic.new
+    assert t.invalid?, "A topic without a title should not be valid"
+    assert t.errors[:author_name].empty?, "A topic without an 'important' title should not require an author"
+
+    t.title = "Just a title"
+    assert t.valid?, "A topic with a basic title should be valid"
+
+    t.title = "A very important title"
+    assert !t.valid?, "A topic with an important title, but without an author, should not be valid"
+    assert t.errors[:author_name].any?, "A topic with an 'important' title should require an author"
+
+    t.author_name = "Hubert J. Farnsworth"
+    assert t.valid?, "A topic with an important title and author should be valid"
+  end
+end
diff --git a/activemodel/test/cases/validations/confirmation_validation_test.rb b/activemodel/test/cases/validations/confirmation_validation_test.rb
new file mode 100644
index 0000000000..1d6f2a6ec5
--- /dev/null
+++ b/activemodel/test/cases/validations/confirmation_validation_test.rb
@@ -0,0 +1,68 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class ConfirmationValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_no_title_confirmation
+    Topic.validates_confirmation_of(:title)
+
+    t = Topic.new(:author_name => "Plutarch")
+    assert t.valid?
+
+    t.title_confirmation = "Parallel Lives"
+    assert !t.valid?
+
+    t.title_confirmation = nil
+    t.title = "Parallel Lives"
+    assert t.valid?
+
+    t.title_confirmation = "Parallel Lives"
+    assert t.valid?
+  end
+
+  def test_title_confirmation
+    Topic.validates_confirmation_of(:title)
+
+    t = Topic.create("title" => "We should be confirmed","title_confirmation" => "")
+    assert !t.save
+
+    t.title_confirmation = "We should be confirmed"
+    assert t.save
+  end
+
+  def test_validates_confirmation_of_with_custom_error_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_confirmation_of :name, :message=> "confirm 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = "John"
+      d.name_confirmation = "Johnny"
+      assert !d.valid?
+      assert_equal ["confirm 'single' and \"double\" quotes"], d.errors[:name]
+    end
+  end
+
+  def test_validates_confirmation_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_confirmation_of :karma
+
+      p = Person.new
+      p.karma_confirmation = "None"
+      assert p.invalid?
+
+      assert_equal ["doesn't match confirmation"], p.errors[:karma]
+
+      p.karma = "None"
+      assert p.valid?
+    end
+  end
+
+end
diff --git a/activemodel/test/cases/validations/exclusion_validation_test.rb b/activemodel/test/cases/validations/exclusion_validation_test.rb
new file mode 100644
index 0000000000..584f009e84
--- /dev/null
+++ b/activemodel/test/cases/validations/exclusion_validation_test.rb
@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/person'
+
+class ExclusionValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_validates_exclusion_of
+    Topic.validates_exclusion_of( :title, :in => %w( abe monkey ) )
+
+    assert Topic.create("title" => "something", "content" => "abc").valid?
+    assert !Topic.create("title" => "monkey", "content" => "abc").valid?
+  end
+
+  def test_validates_exclusion_of_with_formatted_message
+    Topic.validates_exclusion_of( :title, :in => %w( abe monkey ), :message => "option {{value}} is restricted" )
+
+    assert Topic.create("title" => "something", "content" => "abc")
+
+    t = Topic.create("title" => "monkey")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["option monkey is restricted"], t.errors[:title]
+  end
+
+  def test_validates_exclusion_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_exclusion_of :karma, :in => %w( abe monkey )
+
+      p = Person.new
+      p.karma = "abe"
+      assert p.invalid?
+
+      assert_equal ["is reserved"], p.errors[:karma]
+
+      p.karma = "Lifo"
+      assert p.valid?
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/format_validation_test.rb b/activemodel/test/cases/validations/format_validation_test.rb
new file mode 100644
index 0000000000..2c06a9dd02
--- /dev/null
+++ b/activemodel/test/cases/validations/format_validation_test.rb
@@ -0,0 +1,98 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class PresenceValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_validate_format
+    Topic.validates_format_of(:title, :content, :with => /^Validation\smacros \w+!$/, :message => "is bad data")
+
+    t = Topic.create("title" => "i'm incorrect", "content" => "Validation macros rule!")
+    assert !t.valid?, "Shouldn't be valid"
+    assert !t.save, "Shouldn't save because it's invalid"
+    assert_equal ["is bad data"], t.errors[:title]
+    assert t.errors[:content].empty?
+
+    t.title = "Validation macros rule!"
+
+    assert t.save
+    assert t.errors[:title].empty?
+
+    assert_raise(ArgumentError) { Topic.validates_format_of(:title, :content) }
+  end
+
+  def test_validate_format_with_allow_blank
+    Topic.validates_format_of(:title, :with => /^Validation\smacros \w+!$/, :allow_blank=>true)
+    assert !Topic.create("title" => "Shouldn't be valid").valid?
+    assert Topic.create("title" => "").valid?
+    assert Topic.create("title" => nil).valid?
+    assert Topic.create("title" => "Validation macros rule!").valid?
+  end
+
+  # testing ticket #3142
+  def test_validate_format_numeric
+    Topic.validates_format_of(:title, :content, :with => /^[1-9][0-9]*$/, :message => "is bad data")
+
+    t = Topic.create("title" => "72x", "content" => "6789")
+    assert !t.valid?, "Shouldn't be valid"
+    assert !t.save, "Shouldn't save because it's invalid"
+    assert_equal ["is bad data"], t.errors[:title]
+    assert t.errors[:content].empty?
+
+    t.title = "-11"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "03"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "z44"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "5v7"
+    assert !t.valid?, "Shouldn't be valid"
+
+    t.title = "1"
+
+    assert t.save
+    assert t.errors[:title].empty?
+  end
+
+  def test_validate_format_with_formatted_message
+    Topic.validates_format_of(:title, :with => /^Valid Title$/, :message => "can't be {{value}}")
+    t = Topic.create(:title => 'Invalid title')
+    assert_equal ["can't be Invalid title"], t.errors[:title]
+  end
+
+  def test_validates_format_of_with_custom_error_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_format_of :name, :with => /^(A-Z*)$/, :message=> "format 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = d.name_confirmation = "John 32"
+      assert !d.valid?
+      assert_equal ["format 'single' and \"double\" quotes"], d.errors[:name]
+    end
+  end
+
+  def test_validates_format_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_format_of :karma, :with => /\A\d+\Z/
+
+      p = Person.new
+      p.karma = "Pixies"
+      assert p.invalid?
+
+      assert_equal ["is invalid"], p.errors[:karma]
+
+      p.karma = "1234"
+      assert p.valid?
+    end
+  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
new file mode 100644
index 0000000000..37bba5e95e
--- /dev/null
+++ b/activemodel/test/cases/validations/i18n_generate_message_validation_test.rb
@@ -0,0 +1,182 @@
+require "cases/helper"
+require 'cases/tests_database'
+
+require 'models/person'
+
+class I18nGenerateMessageValidationTest < Test::Unit::TestCase
+  def setup
+    reset_callbacks Person
+    @person = Person.new
+
+    @old_load_path, @old_backend = I18n.load_path, I18n.backend
+    I18n.load_path.clear
+    I18n.backend = I18n::Backend::Simple.new
+
+    I18n.backend.store_translations :'en', {
+      :activemodel => {
+        :errors => {
+          :messages => {
+            :inclusion => "is not included in the list",
+            :exclusion => "is reserved",
+            :invalid => "is invalid",
+            :confirmation => "doesn't match confirmation",
+            :accepted  => "must be accepted",
+            :empty => "can't be empty",
+            :blank => "can't be blank",
+            :too_long => "is too long (maximum is {{count}} characters)",
+            :too_short => "is too short (minimum is {{count}} characters)",
+            :wrong_length => "is the wrong length (should be {{count}} characters)",
+            :not_a_number => "is not a number",
+            :greater_than => "must be greater than {{count}}",
+            :greater_than_or_equal_to => "must be greater than or equal to {{count}}",
+            :equal_to => "must be equal to {{count}}",
+            :less_than => "must be less than {{count}}",
+            :less_than_or_equal_to => "must be less than or equal to {{count}}",
+            :odd => "must be odd",
+            :even => "must be even"
+          }
+        }
+      }
+    }
+  end
+
+  def teardown
+    I18n.load_path.replace @old_load_path
+    I18n.backend = @old_backend
+  end
+
+  def reset_callbacks(*models)
+    models.each do |model|
+      model.instance_variable_set("@validate_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    end
+  end
+
+  # validates_inclusion_of: generate_message(attr_name, :inclusion, :default => configuration[: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')
+  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')
+  end
+
+  # validates_exclusion_of: generate_message(attr_name, :exclusion, :default => configuration[: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')
+  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')
+  end
+
+  # validates_associated: generate_message(attr_name, :invalid, :default => configuration[:message], :value => value)
+  # validates_format_of:  generate_message(attr_name, :invalid, :default => configuration[: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')
+  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')
+  end
+
+  # validates_confirmation_of: generate_message(attr_name, :confirmation, :default => configuration[:message])
+  def test_generate_message_confirmation_with_default_message
+    assert_equal "doesn't match confirmation", @person.errors.generate_message(:title, :confirmation, :default => nil)
+  end
+
+  def test_generate_message_confirmation_with_custom_message
+    assert_equal 'custom message', @person.errors.generate_message(:title, :confirmation, :default => 'custom message')
+  end
+
+  # validates_acceptance_of: generate_message(attr_name, :accepted, :default => configuration[:message])
+  def test_generate_message_accepted_with_default_message
+    assert_equal "must be accepted", @person.errors.generate_message(:title, :accepted, :default => nil)
+  end
+
+  def test_generate_message_accepted_with_custom_message
+    assert_equal 'custom message', @person.errors.generate_message(:title, :accepted, :default => 'custom message')
+  end
+
+  # add_on_empty: generate_message(attr, :empty, :default => custom_message)
+  def test_generate_message_empty_with_default_message
+    assert_equal "can't be empty", @person.errors.generate_message(:title, :empty, :default => nil)
+  end
+
+  def test_generate_message_empty_with_custom_message
+    assert_equal 'custom message', @person.errors.generate_message(:title, :empty, :default => 'custom message')
+  end
+
+  # add_on_blank: generate_message(attr, :blank, :default => custom_message)
+  def test_generate_message_blank_with_default_message
+    assert_equal "can't be blank", @person.errors.generate_message(:title, :blank, :default => nil)
+  end
+
+  def test_generate_message_blank_with_custom_message
+    assert_equal 'custom message', @person.errors.generate_message(:title, :blank, :default => 'custom message')
+  end
+
+  # validates_length_of: generate_message(attr, :too_long, :default => options[:too_long], :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)
+  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)
+  end
+
+  # validates_length_of: generate_message(attr, :too_short, :default => options[:too_short], :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)
+  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)
+  end
+
+  # validates_length_of: generate_message(attr, key, :default => 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)
+  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)
+  end
+
+  # validates_numericality_of: generate_message(attr_name, :not_a_number, :value => raw_value, :default => configuration[: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')
+  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')
+  end
+
+  # validates_numericality_of: generate_message(attr_name, option, :value => raw_value, :default => configuration[: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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  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)
+  end
+end
diff --git a/activemodel/test/cases/validations/i18n_validation_test.rb b/activemodel/test/cases/validations/i18n_validation_test.rb
new file mode 100644
index 0000000000..cc68d847a2
--- /dev/null
+++ b/activemodel/test/cases/validations/i18n_validation_test.rb
@@ -0,0 +1,579 @@
+require "cases/helper"
+require 'cases/tests_database'
+
+require 'models/person'
+
+class I18nValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+
+  def setup
+    reset_callbacks Person
+
+    @person = Person.new
+
+    @old_load_path, @old_backend = I18n.load_path, I18n.backend
+    I18n.load_path.clear
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.backend.store_translations('en', :activemodel => {:errors => {:messages => {:custom => nil}}})
+  end
+
+  def teardown
+    reset_callbacks Person
+    I18n.load_path.replace @old_load_path
+    I18n.backend = @old_backend
+  end
+
+  def reset_callbacks(*models)
+    models.each do |model|
+      model.instance_variable_set("@validate_callbacks", ActiveSupport::Callbacks::CallbackChain.new)
+    end
+  end
+
+  def test_percent_s_interpolation_syntax_in_error_messages_was_deprecated
+    assert_not_deprecated do
+      default = "%s interpolation syntax was deprecated"
+      assert_equal default, I18n.t(:does_not_exist, :default => default, :value => 'this')
+    end
+  end
+
+  def test_percent_d_interpolation_syntax_in_error_messages_was_deprecated
+    assert_not_deprecated do
+      default = "%d interpolation syntaxes are deprecated"
+      assert_equal default, I18n.t(:does_not_exist, :default => default, :count => 2)
+    end
+  end
+
+  def test_errors_add_on_empty_generates_message
+    @person.errors.expects(:generate_message).with(:title, :empty, {:default => nil})
+    @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'
+  end
+
+  def test_errors_add_on_blank_generates_message
+    @person.errors.expects(:generate_message).with(:title, :blank, {:default => nil})
+    @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'
+  end
+
+  # ActiveRecord::Validations
+  # 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?
+  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?
+  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?
+  end
+
+  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?
+  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
+
+  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?
+  end
+
+  # validates_length_of :within 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?
+  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
+
+  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?
+  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?
+  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?
+  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?
+  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?
+  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?
+  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 = 'a'
+    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :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 = 'a'
+    @person.errors.expects(:generate_message).with(:title, :not_a_number, {:value => 'a', :default => 'custom'})
+    @person.valid?
+  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?
+  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?
+  end
+
+  def test_validates_numericality_of_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
+
+  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', :activemodel => {:errors => {:messages => {:confirmation => 'global message'}}}
+
+    Person.validates_confirmation_of :title
+    @person.title_confirmation = 'foo'
+    @person.valid?
+    assert_equal ['custom message'], @person.errors[:title]
+  end
+
+  def test_validates_confirmation_of_finds_global_default_translation
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:confirmation => 'global message'}}}
+
+    Person.validates_confirmation_of :title
+    @person.title_confirmation = 'foo'
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  end
+
+  # 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', :activemodel => {:errors => {:messages => {:accepted => 'global message'}}}
+
+    Person.validates_acceptance_of :title, :allow_nil => false
+    @person.valid?
+    assert_equal ['custom message'], @person.errors[:title]
+  end
+
+  def test_validates_acceptance_of_finds_global_default_translation
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:accepted => 'global message'}}}
+
+    Person.validates_acceptance_of :title, :allow_nil => false
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {:errors => {:messages => {:blank => 'global message'}}}
+
+    Person.validates_presence_of :title
+    @person.valid?
+    assert_equal ['custom message'], @person.errors[:title]
+  end
+
+  def test_validates_presence_of_finds_global_default_translation
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:blank => 'global message'}}}
+
+    Person.validates_presence_of :title
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {:errors => {:messages => {:too_short => 'global message'}}}
+
+    Person.validates_length_of :title, :within => 3..5
+    @person.valid?
+    assert_equal ['custom message'], @person.errors[:title]
+  end
+
+  def test_validates_length_of_within_finds_global_default_translation
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:too_short => 'global message'}}}
+
+    Person.validates_length_of :title, :within => 3..5
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {: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', :activemodel => {:errors => {:messages => {:wrong_length => 'global message'}}}
+
+    Person.validates_length_of :title, :is => 5
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  end
+
+  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', :activemodel => {: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', :activemodel => {:errors => {:messages => {:wrong_length => 'global message'}}}
+
+    Person.validates_length_of :title, :is => 5
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {: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', :activemodel => {:errors => {:messages => {:invalid => 'global message'}}}
+
+    Person.validates_format_of :title, :with => /^[1-9][0-9]*$/
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {: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', :activemodel => {:errors => {:messages => {:inclusion => 'global message'}}}
+
+    Person.validates_inclusion_of :title, :in => %w(a b c)
+    @person.valid?
+    assert_equal ['global message'], @person.errors[:title]
+  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', :activemodel => {: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', :activemodel => {: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]
+  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', :activemodel => {: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', :activemodel => {: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]
+  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_a_number => 'custom message'}}}}}}
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:not_a_number => 'global message'}}}
+
+    Person.validates_numericality_of :title, :only_integer => true
+    @person.title = 'a'
+    @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', :activemodel => {: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]
+  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', :activemodel => {: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', :activemodel => {: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]
+  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', :activemodel => {: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', :activemodel => {: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]
+  end
+
+  def test_validations_with_message_symbol_must_translate
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:messages => {:custom_error => "I am a custom error"}}}
+    Person.validates_presence_of :title, :message => :custom_error
+    @person.title = nil
+    @person.valid?
+    assert_equal ["I am a custom error"], @person.errors[:title]
+  end
+
+  def test_validates_with_message_symbol_must_translate_per_attribute
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:attributes => {:title => {:custom_error => "I am a custom error"}}}}}}
+    Person.validates_presence_of :title, :message => :custom_error
+    @person.title = nil
+    @person.valid?
+    assert_equal ["I am a custom error"], @person.errors[:title]
+  end
+
+  def test_validates_with_message_symbol_must_translate_per_model
+    I18n.backend.store_translations 'en', :activemodel => {:errors => {:models => {:person => {:custom_error => "I am a custom error"}}}}
+    Person.validates_presence_of :title, :message => :custom_error
+    @person.title = nil
+    @person.valid?
+    assert_equal ["I am a custom error"], @person.errors[:title]
+  end
+
+  def test_validates_with_message_string
+    Person.validates_presence_of :title, :message => "I am a custom error"
+    @person.title = nil
+    @person.valid?
+    assert_equal ["I am a custom error"], @person.errors[:title]
+  end
+
+end
\ No newline at end of file
diff --git a/activemodel/test/cases/validations/inclusion_validation_test.rb b/activemodel/test/cases/validations/inclusion_validation_test.rb
new file mode 100644
index 0000000000..bc1b0365d2
--- /dev/null
+++ b/activemodel/test/cases/validations/inclusion_validation_test.rb
@@ -0,0 +1,80 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class InclusionValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_validates_inclusion_of
+    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ) )
+
+    assert !Topic.create("title" => "a!", "content" => "abc").valid?
+    assert !Topic.create("title" => "a b", "content" => "abc").valid?
+    assert !Topic.create("title" => nil, "content" => "def").valid?
+
+    t = Topic.create("title" => "a", "content" => "I know you are but what am I?")
+    assert t.valid?
+    t.title = "uhoh"
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is not included in the list"], t.errors[:title]
+
+    assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => nil ) }
+    assert_raise(ArgumentError) { Topic.validates_inclusion_of( :title, :in => 0) }
+
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => "hi!" ) }
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => {} ) }
+    assert_nothing_raised(ArgumentError) { Topic.validates_inclusion_of( :title, :in => [] ) }
+  end
+
+  def test_validates_inclusion_of_with_allow_nil
+    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :allow_nil=>true )
+
+    assert !Topic.create("title" => "a!", "content" => "abc").valid?
+    assert !Topic.create("title" => "", "content" => "abc").valid?
+    assert Topic.create("title" => nil, "content" => "abc").valid?
+  end
+
+  def test_validates_inclusion_of_with_formatted_message
+    Topic.validates_inclusion_of( :title, :in => %w( a b c d e f g ), :message => "option {{value}} is not in the list" )
+
+    assert Topic.create("title" => "a", "content" => "abc").valid?
+
+    t = Topic.create("title" => "uhoh", "content" => "abc")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["option uhoh is not in the list"], t.errors[:title]
+  end
+
+  def test_validates_inclusion_of_with_custom_error_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_inclusion_of :salary, :in => 1000..80000, :message=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.salary = "90,000"
+      assert !d.valid?
+      assert_equal "This string contains 'single' and \"double\" quotes", d.errors[:salary].last
+    end
+  end
+
+  def test_validates_inclusion_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_inclusion_of :karma, :in => %w( abe monkey )
+
+      p = Person.new
+      p.karma = "Lifo"
+      assert p.invalid?
+
+      assert_equal ["is not included in the list"], p.errors[:karma]
+
+      p.karma = "monkey"
+      assert p.valid?
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/length_validation_test.rb b/activemodel/test/cases/validations/length_validation_test.rb
new file mode 100644
index 0000000000..4a2f72feab
--- /dev/null
+++ b/activemodel/test/cases/validations/length_validation_test.rb
@@ -0,0 +1,449 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class LengthValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_validates_length_of_with_allow_nil
+    Topic.validates_length_of( :title, :is => 5, :allow_nil=>true )
+
+    assert !Topic.create("title" => "ab").valid?
+    assert !Topic.create("title" => "").valid?
+    assert Topic.create("title" => nil).valid?
+    assert Topic.create("title" => "abcde").valid?
+  end
+
+  def test_validates_length_of_with_allow_blank
+    Topic.validates_length_of( :title, :is => 5, :allow_blank=>true )
+
+    assert !Topic.create("title" => "ab").valid?
+    assert Topic.create("title" => "").valid?
+    assert Topic.create("title" => nil).valid?
+    assert Topic.create("title" => "abcde").valid?
+  end
+
+  def test_validates_length_of_using_minimum
+    Topic.validates_length_of :title, :minimum => 5
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = "not"
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is too short (minimum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is too short (minimum is 5 characters)"], t.errors[:title]
+
+    t.title = nil
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is too short (minimum is 5 characters)"], t.errors["title"]
+  end
+
+  def test_optionally_validates_length_of_using_minimum
+    Topic.validates_length_of :title, :minimum => 5, :allow_nil => true
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = nil
+    assert t.valid?
+  end
+
+  def test_validates_length_of_using_maximum
+    Topic.validates_length_of :title, :maximum => 5
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = "notvalid"
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert t.valid?
+
+    t.title = nil
+    assert !t.valid?
+  end
+
+  def test_optionally_validates_length_of_using_maximum
+    Topic.validates_length_of :title, :maximum => 5, :allow_nil => true
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = nil
+    assert t.valid?
+  end
+
+  def test_validates_length_of_using_within
+    Topic.validates_length_of(:title, :content, :within => 3..5)
+
+    t = Topic.new("title" => "a!", "content" => "I'm ooooooooh so very long")
+    assert !t.valid?
+    assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
+    assert_equal ["is too long (maximum is 5 characters)"], t.errors[:content]
+
+    t.title = nil
+    t.content = nil
+    assert !t.valid?
+    assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
+    assert_equal ["is too short (minimum is 3 characters)"], t.errors[:content]
+
+    t.title = "abe"
+    t.content  = "mad"
+    assert t.valid?
+  end
+
+  def test_optionally_validates_length_of_using_within
+    Topic.validates_length_of :title, :content, :within => 3..5, :allow_nil => true
+
+    t = Topic.create('title' => 'abc', 'content' => 'abcd')
+    assert t.valid?
+
+    t.title = nil
+    assert t.valid?
+  end
+
+  def test_optionally_validates_length_of_using_within_on_create
+    Topic.validates_length_of :title, :content, :within => 5..10, :on => :create, :too_long => "my string is too long: {{count}}"
+
+    t = Topic.create("title" => "thisisnotvalid", "content" => "whatever")
+    assert !t.save
+    assert t.errors[:title].any?
+    assert_equal ["my string is too long: 10"], t.errors[:title]
+
+    t.title = "butthisis"
+    assert t.save
+
+    t.title = "few"
+    assert t.save
+
+    t.content = "andthisislong"
+    assert t.save
+
+    t.content = t.title = "iamfine"
+    assert t.save
+  end
+
+  def test_optionally_validates_length_of_using_within_on_update
+    Topic.validates_length_of :title, :content, :within => 5..10, :on => :update, :too_short => "my string is too short: {{count}}"
+
+    t = Topic.create("title" => "vali", "content" => "whatever")
+    assert !t.save
+    assert t.errors[:title].any?
+
+    t.title = "not"
+    assert !t.save
+    assert t.errors[:title].any?
+    assert_equal ["my string is too short: 5"], t.errors[:title]
+
+    t.title = "valid"
+    t.content = "andthisistoolong"
+    assert !t.save
+    assert t.errors[:content].any?
+
+    t.content = "iamfine"
+    assert t.save
+  end
+
+  def test_validates_length_of_using_is
+    Topic.validates_length_of :title, :is => 5
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = "notvalid"
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["is the wrong length (should be 5 characters)"], t.errors[:title]
+
+    t.title = ""
+    assert !t.valid?
+
+    t.title = nil
+    assert !t.valid?
+  end
+
+  def test_optionally_validates_length_of_using_is
+    Topic.validates_length_of :title, :is => 5, :allow_nil => true
+
+    t = Topic.create("title" => "valid", "content" => "whatever")
+    assert t.valid?
+
+    t.title = nil
+    assert t.valid?
+  end
+
+  def test_validates_length_of_using_bignum
+    bigmin = 2 ** 30
+    bigmax = 2 ** 32
+    bigrange = bigmin...bigmax
+    assert_nothing_raised do
+      Topic.validates_length_of :title, :is => bigmin + 5
+      Topic.validates_length_of :title, :within => bigrange
+      Topic.validates_length_of :title, :in => bigrange
+      Topic.validates_length_of :title, :minimum => bigmin
+      Topic.validates_length_of :title, :maximum => bigmax
+    end
+  end
+
+  def test_validates_length_of_nasty_params
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>6, :maximum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :maximum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :minimum=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>6, :is=>9) }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :minimum=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :maximum=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :within=>"a") }
+    assert_raise(ArgumentError) { Topic.validates_length_of(:title, :is=>"a") }
+  end
+
+  def test_validates_length_of_custom_errors_for_minimum_with_message
+    Topic.validates_length_of( :title, :minimum=>5, :message=>"boo {{count}}" )
+    t = Topic.create("title" => "uhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["boo 5"], t.errors[:title]
+  end
+
+  def test_validates_length_of_custom_errors_for_minimum_with_too_short
+    Topic.validates_length_of( :title, :minimum=>5, :too_short=>"hoo {{count}}" )
+    t = Topic.create("title" => "uhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors[:title]
+  end
+
+  def test_validates_length_of_custom_errors_for_maximum_with_message
+    Topic.validates_length_of( :title, :maximum=>5, :message=>"boo {{count}}" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["boo 5"], t.errors[:title]
+  end
+
+  def test_validates_length_of_custom_errors_for_in
+    Topic.validates_length_of(:title, :in => 10..20, :message => "hoo {{count}}")
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 10"], t.errors["title"]
+
+    t = Topic.create("title" => "uhohuhohuhohuhohuhohuhohuhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 20"], t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_maximum_with_too_long
+    Topic.validates_length_of( :title, :maximum=>5, :too_long=>"hoo {{count}}" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_is_with_message
+    Topic.validates_length_of( :title, :is=>5, :message=>"boo {{count}}" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["boo 5"], t.errors["title"]
+  end
+
+  def test_validates_length_of_custom_errors_for_is_with_wrong_length
+    Topic.validates_length_of( :title, :is=>5, :wrong_length=>"hoo {{count}}" )
+    t = Topic.create("title" => "uhohuhoh", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["hoo 5"], t.errors["title"]
+  end
+
+  def test_validates_length_of_using_minimum_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :minimum => 5
+
+      t = Topic.create("title" => "一二三四五", "content" => "whatever")
+      assert t.valid?
+
+      t.title = "一二三四"
+      assert !t.valid?
+      assert t.errors[:title].any?
+      assert_equal ["is too short (minimum is 5 characters)"], t.errors["title"]
+    end
+  end
+
+  def test_validates_length_of_using_maximum_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :maximum => 5
+
+      t = Topic.create("title" => "一二三四五", "content" => "whatever")
+      assert t.valid?
+
+      t.title = "一二34五六"
+      assert !t.valid?
+      assert t.errors[:title].any?
+      assert_equal ["is too long (maximum is 5 characters)"], t.errors["title"]
+    end
+  end
+
+  def test_validates_length_of_using_within_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of(:title, :content, :within => 3..5)
+
+      t = Topic.new("title" => "一二", "content" => "12三四五六七")
+      assert !t.valid?
+      assert_equal ["is too short (minimum is 3 characters)"], t.errors[:title]
+      assert_equal ["is too long (maximum is 5 characters)"], t.errors[:content]
+      t.title = "一二三"
+      t.content  = "12三"
+      assert t.valid?
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :within => 3..5, :allow_nil => true
+
+      t = Topic.create(:title => "一二三四五")
+      assert t.valid?, t.errors.inspect
+
+      t = Topic.create(:title => "一二三")
+      assert t.valid?, t.errors.inspect
+
+      t.title = nil
+      assert t.valid?, t.errors.inspect
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_on_create_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :within => 5..10, :on => :create, :too_long => "長すぎます: {{count}}"
+
+      t = Topic.create("title" => "一二三四五六七八九十A", "content" => "whatever")
+      assert !t.save
+      assert t.errors[:title].any?
+      assert_equal "長すぎます: 10", t.errors[:title].first
+
+      t.title = "一二三四五六七八九"
+      assert t.save
+
+      t.title = "一二3"
+      assert t.save
+
+      t.content = "一二三四五六七八九十"
+      assert t.save
+
+      t.content = t.title = "一二三四五六"
+      assert t.save
+    end
+  end
+
+  def test_optionally_validates_length_of_using_within_on_update_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :within => 5..10, :on => :update, :too_short => "短すぎます: {{count}}"
+
+      t = Topic.create("title" => "一二三4", "content" => "whatever")
+      assert !t.save
+      assert t.errors[:title].any?
+
+      t.title = "1二三4"
+      assert !t.save
+      assert t.errors[:title].any?
+      assert_equal ["短すぎます: 5"], t.errors[:title]
+
+      t.title = "一二三四五六七八九十A"
+      assert !t.save
+      assert t.errors[:title].any?
+
+      t.title = "一二345"
+      assert t.save
+    end
+  end
+
+  def test_validates_length_of_using_is_utf8
+    with_kcode('UTF8') do
+      Topic.validates_length_of :title, :is => 5
+
+      t = Topic.create("title" => "一二345", "content" => "whatever")
+      assert t.valid?
+
+      t.title = "一二345六"
+      assert !t.valid?
+      assert t.errors[:title].any?
+      assert_equal ["is the wrong length (should be 5 characters)"], t.errors["title"]
+    end
+  end
+
+  def test_validates_length_of_with_block
+    Topic.validates_length_of :content, :minimum => 5, :too_short=>"Your essay must be at least {{count}} words.",
+                                        :tokenizer => lambda {|str| str.scan(/\w+/) }
+    t = Topic.create!(:content => "this content should be long enough")
+    assert t.valid?
+
+    t.content = "not long enough"
+    assert !t.valid?
+    assert t.errors[:content].any?
+    assert_equal ["Your essay must be at least 5 words."], t.errors[:content]
+  end
+
+  def test_validates_length_of_with_custom_too_long_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_length_of :name, :maximum => 4, :too_long=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = "Jeffrey"
+      assert !d.valid?
+      assert_equal ["This string contains 'single' and \"double\" quotes"], d.errors[:name]
+    end
+  end
+
+  def test_validates_length_of_with_custom_too_short_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_length_of :name, :minimum => 4, :too_short=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = "Joe"
+      assert !d.valid?
+      assert_equal ["This string contains 'single' and \"double\" quotes"], d.errors[:name]
+    end
+  end
+
+  def test_validates_length_of_with_custom_message_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_length_of :name, :minimum => 4, :message=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = "Joe"
+      assert !d.valid?
+      assert_equal ["This string contains 'single' and \"double\" quotes"], d.errors[:name]
+    end
+  end
+
+  def test_validates_length_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_length_of :karma, :minimum => 5
+
+      p = Person.new
+      p.karma = "Pix"
+      assert p.invalid?
+
+      assert_equal ["is too short (minimum is 5 characters)"], p.errors[:karma]
+
+      p.karma = "The Smiths"
+      assert p.valid?
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/numericality_validation_test.rb b/activemodel/test/cases/validations/numericality_validation_test.rb
new file mode 100644
index 0000000000..0af6eb69ce
--- /dev/null
+++ b/activemodel/test/cases/validations/numericality_validation_test.rb
@@ -0,0 +1,179 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class NumericalityValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  NIL = [nil]
+  BLANK = ["", " ", " \t \r \n"]
+  BIGDECIMAL_STRINGS = %w(12345678901234567890.1234567890) # 30 significent digits
+  FLOAT_STRINGS = %w(0.0 +0.0 -0.0 10.0 10.5 -10.5 -0.0001 -090.1 90.1e1 -90.1e5 -90.1e-5 90e-5)
+  INTEGER_STRINGS = %w(0 +0 -0 10 +10 -10 0090 -090)
+  FLOATS = [0.0, 10.0, 10.5, -10.5, -0.0001] + FLOAT_STRINGS
+  INTEGERS = [0, 10, -10] + INTEGER_STRINGS
+  BIGDECIMAL = BIGDECIMAL_STRINGS.collect! { |bd| BigDecimal.new(bd) }
+  JUNK = ["not a number", "42 not a number", "0xdeadbeef", "00-1", "--3", "+-3", "+3-1", "-+019.0", "12.12.13.12", "123\nnot a number"]
+  INFINITY = [1.0/0.0]
+
+  def test_default_validates_numericality_of
+    Topic.validates_numericality_of :approved
+    invalid!(NIL + BLANK + JUNK)
+    valid!(FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+  end
+
+  def test_validates_numericality_of_with_nil_allowed
+    Topic.validates_numericality_of :approved, :allow_nil => true
+
+    invalid!(JUNK)
+    valid!(NIL + BLANK + FLOATS + INTEGERS + BIGDECIMAL + INFINITY)
+  end
+
+  def test_validates_numericality_of_with_integer_only
+    Topic.validates_numericality_of :approved, :only_integer => true
+
+    invalid!(NIL + BLANK + JUNK + FLOATS + BIGDECIMAL + INFINITY)
+    valid!(INTEGERS)
+  end
+
+  def test_validates_numericality_of_with_integer_only_and_nil_allowed
+    Topic.validates_numericality_of :approved, :only_integer => true, :allow_nil => true
+
+    invalid!(JUNK + FLOATS + BIGDECIMAL + INFINITY)
+    valid!(NIL + BLANK + INTEGERS)
+  end
+
+  def test_validates_numericality_with_greater_than
+    Topic.validates_numericality_of :approved, :greater_than => 10
+
+    invalid!([-10, 10], 'must be greater than 10')
+    valid!([11])
+  end
+
+  def test_validates_numericality_with_greater_than_or_equal
+    Topic.validates_numericality_of :approved, :greater_than_or_equal_to => 10
+
+    invalid!([-9, 9], 'must be greater than or equal to 10')
+    valid!([10])
+  end
+
+  def test_validates_numericality_with_equal_to
+    Topic.validates_numericality_of :approved, :equal_to => 10
+
+    invalid!([-10, 11] + INFINITY, 'must be equal to 10')
+    valid!([10])
+  end
+
+  def test_validates_numericality_with_less_than
+    Topic.validates_numericality_of :approved, :less_than => 10
+
+    invalid!([10], 'must be less than 10')
+    valid!([-9, 9])
+  end
+
+  def test_validates_numericality_with_less_than_or_equal_to
+    Topic.validates_numericality_of :approved, :less_than_or_equal_to => 10
+
+    invalid!([11], 'must be less than or equal to 10')
+    valid!([-10, 10])
+  end
+
+  def test_validates_numericality_with_odd
+    Topic.validates_numericality_of :approved, :odd => true
+
+    invalid!([-2, 2], 'must be odd')
+    valid!([-1, 1])
+  end
+
+  def test_validates_numericality_with_even
+    Topic.validates_numericality_of :approved, :even => true
+
+    invalid!([-1, 1], 'must be even')
+    valid!([-2, 2])
+  end
+
+  def test_validates_numericality_with_greater_than_less_than_and_even
+    Topic.validates_numericality_of :approved, :greater_than => 1, :less_than => 4, :even => true
+
+    invalid!([1, 3, 4])
+    valid!([2])
+  end
+
+  def test_validates_numericality_with_numeric_message
+    Topic.validates_numericality_of :approved, :less_than => 4, :message => "smaller than {{count}}"
+    topic = Topic.new("title" => "numeric test", "approved" => 10)
+
+    assert !topic.valid?
+    assert_equal ["smaller than 4"], topic.errors[:approved]
+
+    Topic.validates_numericality_of :approved, :greater_than => 4, :message => "greater than {{count}}"
+    topic = Topic.new("title" => "numeric test", "approved" => 1)
+
+    assert !topic.valid?
+    assert_equal ["greater than 4"], topic.errors[:approved]
+  end
+
+  def test_numericality_with_getter_method
+    repair_validations(Developer) do
+      Developer.validates_numericality_of( :salary )
+      developer = Developer.new("name" => "michael", "salary" => nil)
+      developer.instance_eval("def salary; read_attribute('salary') ? read_attribute('salary') : 100000; end")
+      assert developer.valid?
+    end
+  end
+
+  def test_numericality_with_allow_nil_and_getter_method
+    repair_validations(Developer) do
+      Developer.validates_numericality_of( :salary, :allow_nil => true)
+      developer = Developer.new("name" => "michael", "salary" => nil)
+      developer.instance_eval("def salary; read_attribute('salary') ? read_attribute('salary') : 100000; end")
+      assert developer.valid?
+    end
+  end
+
+  def test_validates_numericality_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_numericality_of :karma, :allow_nil => false
+
+      p = Person.new
+      p.karma = "Pix"
+      assert p.invalid?
+
+      assert_equal ["is not a number"], p.errors[:karma]
+
+      p.karma = "1234"
+      assert p.valid?
+    end
+  end
+
+  private
+
+  def invalid!(values, error = nil)
+    with_each_topic_approved_value(values) do |topic, value|
+      assert !topic.valid?, "#{value.inspect} not rejected as a number"
+      assert topic.errors[:approved].any?, "FAILED for #{value.inspect}"
+      assert_equal error, topic.errors[:approved].first if error
+    end
+  end
+
+  def valid!(values)
+    with_each_topic_approved_value(values) do |topic, value|
+      assert topic.valid?, "#{value.inspect} not accepted as a number"
+    end
+  end
+
+  def with_each_topic_approved_value(values)
+    topic = Topic.new(:title => "numeric test", :content => "whatever")
+    values.each do |value|
+      topic.approved = value
+      yield topic, value
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations/presence_validation_test.rb b/activemodel/test/cases/validations/presence_validation_test.rb
new file mode 100644
index 0000000000..f6bed4903a
--- /dev/null
+++ b/activemodel/test/cases/validations/presence_validation_test.rb
@@ -0,0 +1,57 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/developer'
+require 'models/person'
+
+class PresenceValidationTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  repair_validations(Topic)
+
+  def test_validate_presences
+    Topic.validates_presence_of(:title, :content)
+
+    t = Topic.create
+    assert !t.save
+    assert_equal ["can't be blank"], t.errors[:title]
+    assert_equal ["can't be blank"], t.errors[:content]
+
+    t.title = "something"
+    t.content  = "   "
+
+    assert !t.save
+    assert_equal ["can't be blank"], t.errors[:content]
+
+    t.content = "like stuff"
+
+    assert t.save
+  end
+
+  def test_validates_presence_of_with_custom_message_using_quotes
+    repair_validations(Developer) do
+      Developer.validates_presence_of :non_existent, :message=> "This string contains 'single' and \"double\" quotes"
+      d = Developer.new
+      d.name = "Joe"
+      assert !d.valid?
+      assert_equal ["This string contains 'single' and \"double\" quotes"], d.errors[:non_existent]
+    end
+  end
+
+  def test_validates_presence_of_for_ruby_class
+    repair_validations(Person) do
+      Person.validates_presence_of :karma
+
+      p = Person.new
+      assert p.invalid?
+
+      assert_equal ["can't be blank"], p.errors[:karma]
+
+      p.karma = "Cold"
+      assert p.valid?
+    end
+  end
+end
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
new file mode 100644
index 0000000000..8c89494247
--- /dev/null
+++ b/activemodel/test/cases/validations_test.rb
@@ -0,0 +1,178 @@
+# encoding: utf-8
+require 'cases/helper'
+require 'cases/tests_database'
+
+require 'models/topic'
+require 'models/reply'
+require 'models/developer'
+
+class ValidationsTest < ActiveModel::TestCase
+  include ActiveModel::TestsDatabase
+  include ActiveModel::ValidationsRepairHelper
+
+  # Most of the tests mess with the validations of Topic, so lets repair it all the time.
+  # Other classes we mess with will be dealt with in the specific tests
+  repair_validations(Topic)
+
+  def test_single_field_validation
+    r = Reply.new
+    r.title = "There's no content!"
+    assert !r.valid?, "A reply without content shouldn't be saveable"
+
+    r.content = "Messa content!"
+    assert r.valid?, "A reply with content should be saveable"
+  end
+
+  def test_single_attr_validation_and_error_msg
+    r = Reply.new
+    r.title = "There's no content!"
+    assert !r.valid?
+    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["content"], "A reply without content should contain an error"
+    assert_equal 1, r.errors.count
+  end
+
+  def test_double_attr_validation_and_error_msg
+    r = Reply.new
+    assert !r.valid?
+
+    assert r.errors[:title].any?, "A reply without title should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["title"], "A reply without title should contain an error"
+
+    assert r.errors[:content].any?, "A reply without content should mark that attribute as invalid"
+    assert_equal ["Empty"], r.errors["content"], "A reply without content should contain an error"
+
+    assert_equal 2, r.errors.count
+  end
+
+  def test_single_error_per_attr_iteration
+    r = Reply.new
+    r.save
+
+    errors = []
+    r.errors.each {|attr, messages| errors << [attr.to_s, messages] }
+
+    assert errors.include?(["title", "Empty"])
+    assert errors.include?(["content", "Empty"])
+  end
+
+  def test_multiple_errors_per_attr_iteration_with_full_error_composition
+    r = Reply.new
+    r.title   = "Wrong Create"
+    r.content = "Mismatch"
+    r.save
+
+    errors = r.errors.to_a
+
+    assert_equal "Title is Wrong Create", errors[0]
+    assert_equal "Title is Content Mismatch", errors[1]
+    assert_equal 2, r.errors.count
+  end
+
+  def test_errors_on_base
+    r = Reply.new
+    r.content = "Mismatch"
+    r.save
+    r.errors[:base] << "Reply is not dignifying"
+
+    errors = []
+    r.errors.to_a.each { |error| errors << error }
+
+    assert_equal ["Reply is not dignifying"], r.errors[:base]
+
+    assert errors.include?("Title Empty")
+    assert errors.include?("Reply is not dignifying")
+    assert_equal 2, r.errors.count
+  end
+
+  def test_validates_each
+    hits = 0
+    Topic.validates_each(:title, :content, [:title, :content]) do |record, attr|
+      record.errors.add attr, 'gotcha'
+      hits += 1
+    end
+    t = Topic.new("title" => "valid", "content" => "whatever")
+    assert !t.save
+    assert_equal 4, hits
+    assert_equal %w(gotcha gotcha), t.errors[:title]
+    assert_equal %w(gotcha gotcha), t.errors[:content]
+  end
+
+  def test_validate_block
+    Topic.validate { |topic| topic.errors.add("title", "will never be valid") }
+    t = Topic.create("title" => "Title", "content" => "whatever")
+    assert !t.valid?
+    assert t.errors[:title].any?
+    assert_equal ["will never be valid"], t.errors["title"]
+  end
+
+  def test_invalid_validator
+    Topic.validate 3
+    assert_raise(ArgumentError) { t = Topic.create }
+  end
+
+  def test_errors_to_xml
+    r = Reply.new :title => "Wrong Create"
+    assert !r.valid?
+    xml = r.errors.to_xml(:skip_instruct => true)
+    assert_equal "<errors>", xml.first(8)
+    assert xml.include?("<error>Title is Wrong Create</error>")
+    assert xml.include?("<error>Content Empty</error>")
+  end
+
+  def test_validation_order
+     Topic.validates_presence_of :title
+     Topic.validates_length_of :title, :minimum => 2
+
+     t = Topic.new("title" => "")
+     assert !t.valid?
+     assert_equal "can't be blank", t.errors["title"].first
+  end
+
+  def test_invalid_should_be_the_opposite_of_valid
+    Topic.validates_presence_of :title
+
+    t = Topic.new
+    assert t.invalid?
+    assert t.errors[:title].any?
+
+    t.title = 'Things are going to change'
+    assert !t.invalid?
+  end
+
+  def test_deprecated_error_messages_on
+    Topic.validates_presence_of :title
+
+    t = Topic.new
+    assert t.invalid?
+
+    [:title, "title"].each do |attribute|
+      assert_deprecated { assert_equal "can't be blank", t.errors.on(attribute) }
+    end
+
+    Topic.validates_each(:title) do |record, attribute|
+      record.errors[attribute] << "invalid"
+    end
+
+    assert t.invalid?
+
+    [:title, "title"].each do |attribute|
+      assert_deprecated do
+        assert t.errors.on(attribute).include?("invalid")
+        assert t.errors.on(attribute).include?("can't be blank")
+      end
+    end
+  end
+
+  def test_deprecated_errors_on_base_and_each
+    t = Topic.new
+    assert t.valid?
+
+    assert_deprecated { t.errors.add_to_base "invalid topic" }
+    assert_deprecated { assert_equal "invalid topic", t.errors.on_base }
+    assert_deprecated { assert t.errors.invalid?(:base) }
+
+    all_errors = t.errors.to_a
+    assert_deprecated { assert_equal all_errors, t.errors.each_full{|err| err} }
+  end
+end
\ No newline at end of file
diff --git a/activemodel/test/config.rb b/activemodel/test/config.rb
new file mode 100644
index 0000000000..0b577a9936
--- /dev/null
+++ b/activemodel/test/config.rb
@@ -0,0 +1,3 @@
+TEST_ROOT       = File.expand_path(File.dirname(__FILE__))
+FIXTURES_ROOT   = TEST_ROOT + "/fixtures"
+SCHEMA_FILE     = TEST_ROOT + "/schema.rb"
diff --git a/activemodel/test/fixtures/topics.yml b/activemodel/test/fixtures/topics.yml
new file mode 100644
index 0000000000..e4c61ce2d8
--- /dev/null
+++ b/activemodel/test/fixtures/topics.yml
@@ -0,0 +1,41 @@
+first:
+  id: 1
+  title: The First Topic
+  author_name: David
+  author_email_address: david@loudthinking.com
+  written_on: 2003-07-16t15:28:11.2233+01:00
+  last_read: 2004-04-15
+  bonus_time: 2005-01-30t15:28:00.00+01:00
+  content: Have a nice day
+  approved: false
+  replies_count: 1
+
+second:
+  id: 2
+  title: The Second Topic of the day
+  author_name: Mary
+  written_on: 2004-07-15t15:28:00.0099+01:00
+  content: Have a nice day
+  approved: true
+  replies_count: 0
+  parent_id: 1
+  type: Reply
+
+third:
+  id: 3
+  title: The Third Topic of the day
+  author_name: Nick
+  written_on: 2005-07-15t15:28:00.0099+01:00
+  content: I'm a troll
+  approved: true
+  replies_count: 1
+
+fourth:
+  id: 4
+  title: The Fourth Topic of the day
+  author_name: Carl
+  written_on: 2006-07-15t15:28:00.0099+01:00
+  content: Why not?
+  approved: true
+  type: Reply
+  parent_id: 3
diff --git a/activemodel/test/models/developer.rb b/activemodel/test/models/developer.rb
new file mode 100644
index 0000000000..5e6eefeed1
--- /dev/null
+++ b/activemodel/test/models/developer.rb
@@ -0,0 +1,6 @@
+class Developer < ActiveRecord::Base
+  validates_inclusion_of :salary, :in => 50000..200000
+  validates_length_of :name, :within => 3..20
+
+  attr_accessor :name_confirmation
+end
diff --git a/activemodel/test/models/person.rb b/activemodel/test/models/person.rb
new file mode 100644
index 0000000000..d98420f900
--- /dev/null
+++ b/activemodel/test/models/person.rb
@@ -0,0 +1,5 @@
+class Person
+  include ActiveModel::Validations
+
+  attr_accessor :title, :karma
+end
diff --git a/activemodel/test/models/reply.rb b/activemodel/test/models/reply.rb
new file mode 100644
index 0000000000..acfd801674
--- /dev/null
+++ b/activemodel/test/models/reply.rb
@@ -0,0 +1,34 @@
+require 'models/topic'
+
+class Reply < Topic
+  validate :errors_on_empty_content
+  validate_on_create :title_is_wrong_create
+
+  validate :check_empty_title
+  validate_on_create :check_content_mismatch
+  validate_on_update :check_wrong_update
+
+  attr_accessible :title, :author_name, :author_email_address, :written_on, :content, :last_read
+
+  def check_empty_title
+    errors[:title] << "Empty" unless attribute_present?("title")
+  end
+
+  def errors_on_empty_content
+    errors[:content] << "Empty" unless attribute_present?("content")
+  end
+
+  def check_content_mismatch
+    if attribute_present?("title") && attribute_present?("content") && content == "Mismatch"
+      errors[:title] << "is Content Mismatch"
+    end
+  end
+
+  def title_is_wrong_create
+    errors[:title] << "is Wrong Create" if attribute_present?("title") && title == "Wrong Create"
+  end
+
+  def check_wrong_update
+    errors[:title] << "is Wrong Update" if attribute_present?("title") && title == "Wrong Update"
+  end
+end
diff --git a/activemodel/test/models/topic.rb b/activemodel/test/models/topic.rb
new file mode 100644
index 0000000000..1350aa17e7
--- /dev/null
+++ b/activemodel/test/models/topic.rb
@@ -0,0 +1,9 @@
+class Topic < ActiveRecord::Base
+  def condition_is_true
+    true
+  end
+
+  def condition_is_true_but_its_not
+    false
+  end
+end
diff --git a/activemodel/test/schema.rb b/activemodel/test/schema.rb
new file mode 100644
index 0000000000..56b824d445
--- /dev/null
+++ b/activemodel/test/schema.rb
@@ -0,0 +1,14 @@
+ActiveRecord::Schema.define do
+  create_table :topics, :force => true do |t|
+    t.string  :title
+    t.string  :author_name
+    t.text    :content
+    t.boolean :approved, :default => true
+    t.string  :type
+  end
+
+  create_table :developers, :force => true do |t|
+    t.string  :name
+    t.float   :salary
+  end
+end
diff --git a/activemodel/test/test_helper.rb b/activemodel/test/test_helper.rb
deleted file mode 100644
index 5b5678e42d..0000000000
--- a/activemodel/test/test_helper.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-require 'rubygems'
-require 'test/unit'
-
-gem 'mocha', '>= 0.9.3'
-require 'mocha'
-
-require 'active_model'
-require 'active_model/state_machine'
-
-$:.unshift File.dirname(__FILE__) + "/../../activesupport/lib"
-require 'active_support'
-require 'active_support/test_case'
-
-class ActiveModel::TestCase < ActiveSupport::TestCase
-end
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-rescue LoadError
-end