Ticket #10876: extract_validations.patch

a/activerecord/lib/active_record/validations.rb

@@ -14 +14 @@
-    end
-  end
-
-  # Active Record validation is reported to and from this object, which is used by Base#save to
-  # determine whether the object is in a valid state to be saved. See usage example in Validations.
-  class Errors
-    include Enumerable
-
-    def initialize(base) # :nodoc:
-      @base, @errors = base, {}
-    end
-
-    @@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"
-    }
-
-    # Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
-    cattr_accessor :default_error_messages
-
-
-    # Adds an error to the base object instead of any particular attribute. This is used
-    # to report errors that don't tie to any specific attribute, but rather to the object
-    # as a whole. These error messages don't get prepended with any field name when iterating
-    # with each_full, so they should be complete sentences.
-    def add_to_base(msg)
-      add(:base, msg)
-    end
-
-    # Adds an error message (+msg+) 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 +msg+ is supplied, "invalid" is assumed.
-    def add(attribute, msg = @@default_error_messages[:invalid])
-      @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
-      @errors[attribute.to_s] << msg
-    end
-
-    # Will add an error message to each of the attributes in +attributes+ that is empty.
-    def add_on_empty(attributes, msg = @@default_error_messages[:empty])
-      for attr in [attributes].flatten
-        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
-        is_empty = value.respond_to?("empty?") ? value.empty? : false
-        add(attr, msg) 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, msg = @@default_error_messages[:blank])
-      for attr in [attributes].flatten
-        value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
-        add(attr, msg) if value.blank?
-      end
-    end
-
-    # Returns true if the specified +attribute+ has errors associated with it.
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.invalid?(:name)      # => true
-    #   company.errors.invalid?(:address)   # => false
-    def invalid?(attribute)
-      !@errors[attribute.to_s].nil?
-    end
-
-    # Returns nil, if no errors are associated with the specified +attribute+.
-    # Returns the error message, if one error is associated with the specified +attribute+.
-    # Returns an array of error messages, if more than one error is associated with the specified +attribute+.
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.on(:name)      # => ["is too short (minimum is 5 characters)", "can't be blank"]
-    #   company.errors.on(:email)     # => "can't be blank"
-    #   company.errors.on(:address)   # => nil
-    def on(attribute)
-      errors = @errors[attribute.to_s]
-      return nil if errors.nil?
-      errors.size == 1 ? errors.first : errors
-    end
-
-    alias :[] :on
-
-    # Returns errors assigned to the base object through add_to_base according to the normal rules of on(attribute).
-    def on_base
-      on(:base)
-    end
-
-    # Yields each attribute and associated message per error added.
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.each{|attr,msg| puts "#{attr} - #{msg}" } # =>
-    #     name - is too short (minimum is 5 characters)
-    #     name - can't be blank
-    #     address - can't be blank
-    def each
-      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
-    end
-
-    # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
-    # through iteration as "First name can't be empty".
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.each_full{|msg| puts msg } # =>
-    #     Name is too short (minimum is 5 characters)
-    #     Name can't be blank
-    #     Address can't be blank
-    def each_full
-      full_messages.each { |msg| yield msg }
-    end
-
-    # Returns all the full error messages in an array.
-    #
-    #   class Company < ActiveRecord::Base
-    #     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
-      full_messages = []
-
-      @errors.each_key do |attr|
-        @errors[attr].each do |msg|
-          next if msg.nil?
-
-          if attr == "base"
-            full_messages << msg
-          else
-            full_messages << @base.class.human_attribute_name(attr) + " " + msg
-          end
-        end
-      end
-      full_messages
-    end
-
-    # Returns true if no errors have been added.
-    def empty?
-      @errors.empty?
-    end
-
-    # Removes all errors that have been added.
-    def clear
-      @errors = {}
-    end
-
-    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.
-    def size
-      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
-    end
-
-    alias_method :count, :size
-    alias_method :length, :size
-
-    # Return an XML representation of this error object.
-    #
-    #   class Company < ActiveRecord::Base
-    #     validates_presence_of :name, :address, :email
-    #     validates_length_of :name, :in => 5..30
-    #   end
-    #
-    #   company = Company.create(:address => '123 First St.')
-    #   company.errors.to_xml # =>
-    #     <?xml version="1.0" encoding="UTF-8"?>
-    #     <errors>
-    #       <error>Name is too short (minimum is 5 characters)</error>
-    #       <error>Name can't be blank</error>
-    #       <error>Address can't be blank</error>
-    #     </errors>
-    def to_xml(options={})
-      options[:root] ||= "errors"
-      options[:indent] ||= 2
-      options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-
-      options[:builder].instruct! unless options.delete(:skip_instruct)
-      options[:builder].errors do |e|
-        full_messages.each { |msg| e.error(msg) }
-      end
-    end
-  end
-
-
-  # Active Records implement validation by overwriting Base#validate (or the variations, +validate_on_create+ and
-  # +validate_on_update+). Each of these methods can inspect the state of the object, which usually means ensuring
-  # that a number of attributes have a certain value (such as not empty, within a given range, matching a certain regular expression).
@@ -270 +55 @@
-  #
-  # Please do have a look at ActiveRecord::Validations::ClassMethods for a higher level of validations.
-  module Validations
-
-
+
-    def self.included(base) # :nodoc:
+      base.send :include, ActiveSupport::Validations
+      base.default_validation_options[:on] = :save
+      
-      base.extend ClassMethods
+      
-      base.class_eval do
-        alias_method_chain :save, :validation
-        alias_method_chain :save!, :validation
-        alias_method_chain :update_attribute, :validation_skipping
-      end
-
-      base.send :include, ActiveSupport::Callbacks
-
-      # TODO: Use helper ActiveSupport::Callbacks#define_callbacks instead
- validate
+
-        base.class_eval <<-"end_eval"
-          def self.#{validation_method}(*methods, &block)
-            options = methods.extract_options!
@@ -304 +90 @@
-    # They offer a more declarative way of specifying when the model is valid and when it is not. It is recommended to use
-    # these over the low-level calls to validate and validate_on_create when possible.
-    module ClassMethods
-      DEFAULT_VALIDATION_OPTIONS = {
-        :on => :save,
-        :allow_nil => false,
-        :allow_blank => false,
-        :message => nil
-      }.freeze
-
-      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
-      ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
-                                  :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
-                                  :odd => 'odd?', :even => 'even?' }.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.
@@ -363 +137 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_each(*attrs)
-
-
-
-
-
-
-
-
-
-
-
+
-      end
-
-      # Encapsulates the pattern of wanting to validate a password or email address field with a confirmation. Example:
@@ -405 +169 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.      
-      def validates_confirmation_of(*attr_names)
-
-
-
-
-
-
-
-
+
-      end
-
-      # Encapsulates the pattern of wanting to validate the acceptance of a terms of service check box (or similar agreement). Example:
@@ -439 +196 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.      
-      def validates_acceptance_of(*attr_names)
-
+
+
-        configuration.update(attr_names.extract_options!)
-
+
-        db_cols = begin
-          column_names
-        rescue ActiveRecord::StatementInvalid
@@ -450 +208 @@
-        names = attr_names.reject { |name| db_cols.include?(name.to_s) }
-        attr_accessor(*names)
-
-
+ 
-          record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
-        end
-      end
@@ -489 +247 @@
-      # failures on saves when both the parent object and the child object are
-      # new.
-      def validates_presence_of(*attr_names)
-
-
-
-
-
-
-
-
+
-      end
-
-      # Validates that the specified attribute matches the length restrictions supplied. Only one option can be used at a time:
@@ -532 +283 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.      
-      def validates_length_of(*attrs)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-      end
-
-
-
-
+
+
+
+
+
-      # 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".
-      #
@@ -625 +324 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_uniqueness_of(*attr_names)
-Record
+Support::Validations
-        configuration.update(attr_names.extract_options!)
-
-
+ 
-          if value.nil? || (configuration[:case_sensitive] || !columns_hash[attr_name.to_s].text?)
-            condition_sql = "#{record.class.quoted_table_name}.#{attr_name} #{attribute_condition(value)}"
-            condition_params = [value]
@@ -693 +392 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_format_of(*attr_names)
-
-
-
-
-
-
-
-
+
-      end
-
-      # Validates whether the value of the specified attribute is available in a particular enumerable object.
@@ -723 +415 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_inclusion_of(*attr_names)
-
-
-
-
-
-
-
-
-
-
+
-      end
-
-      # Validates that the value of the specified attribute is not in a particular enumerable object.
@@ -755 +438 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_exclusion_of(*attr_names)
-
-
-
-
-
-
-
-
-
-
+
-      end
-
-      # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
@@ -799 +473 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_associated(*attr_names)
-Record
+Support::Validations
-        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 }
@@ -835 +509 @@
-      #   not occur (e.g. :unless => :skip_validation, or :unless => Proc.new { |user| user.signup_step <= 2 }).  The
-      #   method, proc or string should return or evaluate to a true or false value.
-      def validates_numericality_of(*attr_names)
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-      end
-
-      # Creates an object just like Base.create but calls save! instead of save
@@ -889 +525 @@
-      end
-
-      private
-n
-n
+ptions
+ptions[:on] || :save
-            when :save   then :validate
-            when :create then :validate_on_create
-            when :update then :validate_on_update
@@ -929 +565 @@
-    # Runs validate and validate_on_create or validate_on_update and returns true if no errors were added otherwise false.
-    def valid?
-      errors.clear
-
-      run_callbacks(:validate)
-      validate
-
@@ -944 +579 @@
-      errors.empty?
-    end
-
-    # Returns the Errors object that holds all information about attribute error messages.
-    def errors
-      @errors ||= Errors.new(self)
-    end
-
-    protected
-
-
-
+
+
+
+
-
-  
-  
-  
+
+
+
-
-  
-  
-  
+
+
+
-  end
-end

a/activerecord/test/cases/validations_test.rb

@@ -781 +781 @@
-  end
-
-  def test_validates_length_with_globally_modified_error_message
-Record
+Support::Validations
-    Topic.validates_length_of :title, :minimum => 10
-    t = Topic.create(:title => 'too short')
-    assert !t.valid?

a/activesupport/lib/active_support.rb

@@ -50 +50 @@
-require 'active_support/multibyte'
-
-require 'active_support/base64'
+require 'active_support/validations'

/dev/null

@@ +1 @@
+module ActiveSupport
+  module Validations    
+    class Errors
+      include Enumerable
+
+      def initialize(base) # :nodoc:
+        @base, @errors = base, {}
+      end
+
+      @@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"
+      }
+
+      # Holds a hash with all the default error messages that can be replaced by your own copy or localizations.
+      cattr_accessor :default_error_messages
+
+      # Adds an error to the base object instead of any particular attribute. This is used
+      # to report errors that don't tie to any specific attribute, but rather to the object
+      # as a whole. These error messages don't get prepended with any field name when iterating
+      # with each_full, so they should be complete sentences.
+      def add_to_base(msg)
+        add(:base, msg)
+      end
+
+      # Adds an error message (+msg+) 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 +msg+ is supplied, "invalid" is assumed.
+      def add(attribute, msg = @@default_error_messages[:invalid])
+        @errors[attribute.to_s] = [] if @errors[attribute.to_s].nil?
+        @errors[attribute.to_s] << msg
+      end
+
+      # Will add an error message to each of the attributes in +attributes+ that is empty.
+      def add_on_empty(attributes, msg = @@default_error_messages[:empty])
+        for attr in [attributes].flatten
+          value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+          is_empty = value.respond_to?("empty?") ? value.empty? : false
+          add(attr, msg) 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, msg = @@default_error_messages[:blank])
+        for attr in [attributes].flatten
+          value = @base.respond_to?(attr.to_s) ? @base.send(attr.to_s) : @base[attr.to_s]
+          add(attr, msg) if value.blank?
+        end
+      end
+
+      # Returns true if the specified +attribute+ has errors associated with it.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.invalid?(:name)      # => true
+      #   company.errors.invalid?(:address)   # => false
+      def invalid?(attribute)
+        !@errors[attribute.to_s].nil?
+      end
+
+      # Returns nil, if no errors are associated with the specified +attribute+.
+      # Returns the error message, if one error is associated with the specified +attribute+.
+      # Returns an array of error messages, if more than one error is associated with the specified +attribute+.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.on(:name)      # => ["is too short (minimum is 5 characters)", "can't be blank"]
+      #   company.errors.on(:email)     # => "can't be blank"
+      #   company.errors.on(:address)   # => nil
+      def on(attribute)
+        errors = @errors[attribute.to_s]
+        return nil if errors.nil?
+        errors.size == 1 ? errors.first : errors
+      end
+
+      alias :[] :on
+
+      # Returns errors assigned to the base object through add_to_base according to the normal rules of on(attribute).
+      def on_base
+        on(:base)
+      end
+
+      # Yields each attribute and associated message per error added.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.each{|attr,msg| puts "#{attr} - #{msg}" } # =>
+      #     name - is too short (minimum is 5 characters)
+      #     name - can't be blank
+      #     address - can't be blank
+      def each
+        @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+      end
+
+      # Yields each full error message added. So Person.errors.add("first_name", "can't be empty") will be returned
+      # through iteration as "First name can't be empty".
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.each_full{|msg| puts msg } # =>
+      #     Name is too short (minimum is 5 characters)
+      #     Name can't be blank
+      #     Address can't be blank
+      def each_full
+        full_messages.each { |msg| yield msg }
+      end
+
+      # Returns all the full error messages in an array.
+      #
+      #   class Company < ActiveRecord::Base
+      #     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
+        full_messages = []
+
+        @errors.each_key do |attr|
+          @errors[attr].each do |msg|
+            next if msg.nil?
+
+            if attr == "base"
+              full_messages << msg
+            else
+              if @base.class.respond_to?(:human_attribute_name)
+                full_messages << @base.class.human_attribute_name(attr) + " " + msg
+              else
+                full_messages << attr.humanize + " " + msg
+              end
+            end
+          end
+        end
+        full_messages
+      end
+
+      # Returns true if no errors have been added.
+      def empty?
+        @errors.empty?
+      end
+
+      # Removes all errors that have been added.
+      def clear
+        @errors = {}
+      end
+
+      # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.
+      def size
+        @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+      end
+
+      alias_method :count, :size
+      alias_method :length, :size
+
+      # Return an XML representation of this error object.
+      #
+      #   class Company < ActiveRecord::Base
+      #     validates_presence_of :name, :address, :email
+      #     validates_length_of :name, :in => 5..30
+      #   end
+      #
+      #   company = Company.create(:address => '123 First St.')
+      #   company.errors.to_xml # =>
+      #     <?xml version="1.0" encoding="UTF-8"?>
+      #     <errors>
+      #       <error>Name is too short (minimum is 5 characters)</error>
+      #       <error>Name can't be blank</error>
+      #       <error>Address can't be blank</error>
+      #     </errors>
+      def to_xml(options={})
+        options[:root] ||= "errors"
+        options[:indent] ||= 2
+        options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+        options[:builder].instruct! unless options.delete(:skip_instruct)
+        options[:builder].errors do |e|
+          full_messages.each { |msg| e.error(msg) }
+        end
+      end
+    end
+
+    def self.included(base)
+      base.send :include, ActiveSupport::Callbacks
+      base.cattr_accessor :default_validation_options
+      base.default_validation_options = {}
+      
+      base.extend ClassMethods
+    end
+
+    # All of the following validations are defined in the class scope of the model that you're interested in validating.
+    # They offer a more declarative way of specifying when the model is valid and when it is not. It is recommended to use
+    # these over the low-level calls to validate and validate_on_create when possible.
+    module ClassMethods
+      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :maximum ].freeze
+      ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
+                                  :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
+                                  :odd => 'odd?', :even => 'even?' }.freeze
+                                  
+      def validate(*methods, &block)
+        options = methods.extract_options!
+        methods << block if block_given?
+        methods.map! { |method| ActiveSupport::Callbacks::Callback.new(:validate, method, options) }
+        existing_methods = read_inheritable_attribute(:validate) || []
+        write_inheritable_attribute(:validate, existing_methods | methods)
+      end
+
+      def validate_callback_chain
+        read_inheritable_attribute(:validate) || []
+      end
+      
+      def validates_each(*attrs)
+        options = attrs.extract_options!.symbolize_keys.reverse_merge(self.default_validation_options)
+        attrs   = attrs.flatten
+
+        # Declare the validation.
+        send(validation_method(options), options) do |record|
+          attrs.each do |attr|
+            value = record.send(attr)
+            next if (value.nil? && options[:allow_nil]) || (value.blank? && options[:allow_blank])
+            yield record, attr, value
+          end
+        end
+      end
+         
+      def validates_confirmation_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:confirmation] }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_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")
+        end
+      end
+
+      def validates_acceptance_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:accepted], :allow_nil => true, :accept => "1" }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_options)
+
+        attr_accessor(*attr_names)
+        
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless value == configuration[:accept]
+        end
+      end
+
+      def validates_presence_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:blank] }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_options)
+
+        # can't use validates_each here, because it cannot cope with nonexistent attributes,
+        # while errors.add_on_empty can
+        send(validation_method(configuration), configuration) do |record|
+          record.errors.add_on_blank(attr_names, configuration[:message])
+        end
+      end
+   
+      def validates_length_of(*attrs)
+        # Merge given options with defaults.
+        options = {
+          :too_long     => ActiveSupport::Validations::Errors.default_error_messages[:too_long],
+          :too_short    => ActiveSupport::Validations::Errors.default_error_messages[:too_short],
+          :wrong_length => ActiveSupport::Validations::Errors.default_error_messages[:wrong_length]
+        }.merge({ :allow_nil => false, :allow_blank => false, :message => nil })
+        
+        options.update(attrs.extract_options!.symbolize_keys).reverse_merge!(self.default_validation_options)
+
+        # 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.'
+        end
+
+        # Get range option and value.
+        option = range_options.first
+        option_value = options[range_options.first]
+
+        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
+
+            validates_each(attrs, options) do |record, attr, value|
+              if value.nil? or value.split(//).size < option_value.begin
+                record.errors.add(attr, too_short)
+              elsif value.split(//).size > option_value.end
+                record.errors.add(attr, too_long)
+              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 }
+
+            message = (options[:message] || options[message_options[option]]) % option_value
+
+            validates_each(attrs, options) do |record, attr, value|
+              if value.kind_of?(String)
+                record.errors.add(attr, message) unless !value.nil? and value.split(//).size.method(validity_checks[option])[option_value]
+              else
+                record.errors.add(attr, message) unless !value.nil? and value.size.method(validity_checks[option])[option_value]
+              end
+            end
+        end
+      end
+
+      def validates_size_of(*attr_names)
+        validates_length_of(*attr_names)
+      end
+
+      def validates_format_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:invalid], :with => nil }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_options)
+
+        unless configuration[:with].is_a?(Regexp)
+          raise(ArgumentError, "A regular expression must be supplied as the :with option of the configuration hash")
+        end
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message]) unless value.to_s =~ configuration[:with]
+        end
+      end
+
+      def validates_inclusion_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:inclusion] }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_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)
+        end
+      end
+
+      def validates_exclusion_of(*attr_names)
+        configuration = { :message => ActiveSupport::Validations::Errors.default_error_messages[:exclusion] }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_options)
+
+        enum = configuration[:in] || configuration[:within]
+
+        unless enum.respond_to?("include?")
+          raise(ArgumentError, "An object with the method include? is required must be supplied as the :in option of the configuration hash")
+        end
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          record.errors.add(attr_name, configuration[:message] % value) if enum.include?(value)
+        end
+      end
+
+      def validates_numericality_of(*attr_names)
+        configuration = { :only_integer => false, :allow_nil => false }
+        configuration.update(attr_names.extract_options!).reverse_merge!(self.default_validation_options)
+
+        numericality_options = ALL_NUMERICALITY_CHECKS.keys & configuration.keys
+
+        (numericality_options - [ :odd, :even ]).each do |option|
+          raise ArgumentError, ":#{option} must be a number" unless configuration[option].is_a?(Numeric)
+        end
+
+        validates_each(attr_names, configuration) do |record, attr_name, value|
+          raw_value = nil
+          if record.respond_to?("#{attr_name}_before_type_cast")
+            raw_value = record.send("#{attr_name}_before_type_cast")
+          end          
+          raw_value ||= value
+
+          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] || ActiveSupport::Validations::Errors.default_error_messages[:not_a_number])
+              next
+            end
+            raw_value = raw_value.to_i
+          else
+           begin
+              raw_value = Kernel.Float(raw_value.to_s)
+            rescue ArgumentError, TypeError
+              record.errors.add(attr_name, configuration[:message] || ActiveSupport::Validations::Errors.default_error_messages[:not_a_number])
+              next
+            end
+          end
+
+          numericality_options.each do |option|
+            case option
+              when :odd, :even
+                unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
+                  record.errors.add(attr_name, configuration[:message] || ActiveSupport::Validations::Errors.default_error_messages[option])
+                end
+              else
+                unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]
+                  record.errors.add(attr_name, configuration[:message] || (ActiveSupport::Validations::Errors.default_error_messages[option] % configuration[option]))
+                end
+            end
+          end
+        end
+      end
+
+      private
+        def validation_method(configuration)
+          :validate
+        end
+    end
+    
+    # Runs validate and returns true if no errors were added otherwise false.
+    def is_valid?
+      errors.clear
+      run_callbacks(:validate)
+      validate
+      errors.empty?
+    end
+
+    # Returns the Errors object that holds all information about attribute error messages.
+    def errors
+      @errors ||= ActiveSupport::Validations::Errors.new(self)
+    end
+    
+    protected
+    
+    def validate
+    end
+    
+  end
+end

/dev/null

@@ +1 @@
+require 'abstract_unit'
+
+class Car
+  include ActiveSupport::Validations
+  attr_accessor :name, :age
+  
+  validates_presence_of :name
+end
+
+class Ferrari < Car
+  attr_accessor :speed
+  
+  validates_numericality_of :speed
+  validates_presence_of :name, :message => "missing name"
+end
+
+class ValidationsTest < Test::Unit::TestCase
+  
+  def setup
+    @car = Car.new    
+    @ferrari = Ferrari.new
+  end
+  
+  def test_validates_presence_of
+    assert !@car.is_valid?
+    assert_equal "can't be blank", @car.errors[:name]
+    
+    @car.name = "Zen"
+    assert @car.is_valid?
+    assert @car.errors.empty?
+  end
+  
+  def test_validates_numericality_of
+    assert !@ferrari.is_valid?
+    
+    assert_equal "is not a number", @ferrari.errors[:speed]
+    assert_equal ["can't be blank", "missing name"], @ferrari.errors[:name]
+    
+    @ferrari.name = "Vrummmm"
+    @ferrari.speed = 200
+    
+    assert @ferrari.is_valid?
+  end
+  
+end