Merge branch 'master' into set_binds

* master: (2794 commits)
  doc, API example on how to use `Model#exists?` with multiple IDs. [ci skip]
  Restore DATABASE_URL even if it's nil in connection_handler test
  [ci skip] - error_messages_for has been deprecated since 2.3.8 - lets reduce any confusion for users
  Ensure Active Record connection consistency
  Revert "ask the fixture set for the sql statements"
  Check `respond_to` before delegation due to: https://github.com/ruby/ruby/commit/d781caaf313b8649948c107bba277e5ad7307314
  Adding Hash#compact and Hash#compact! methods
  MySQL version 4.1 was EOL on December 31, 2009 We should at least recommend modern versions of MySQL to users.
  clear cache on body close so that cache remains during rendering
  add a more restricted codepath for templates fixes #13390
  refactor generator tests to use block form of Tempfile
  Fix typo [ci skip]
  Move finish_template as the last public method in the generator
  Minor typos fix [ci skip]
  make `change_column_null` reversible. Closes #13576.
  create/drop test and development databases only if RAILS_ENV is nil
  Revert "Speedup String#to"
  typo fix in test name. [ci skip].
  `core_ext/string/access.rb` test what we are documenting.
  Fix typo in image_tag documentation
  ...

Conflicts:
	activerecord/lib/active_record/associations/join_dependency/join_association.rb
	activerecord/lib/active_record/relation/query_methods.rb

49 files changed, 484 insertions, 325 deletions

diff --git a/activemodel/CHANGELOG.md b/activemodel/CHANGELOG.md
index eb54b58888..09fdd84844 100644
--- a/activemodel/CHANGELOG.md
+++ b/activemodel/CHANGELOG.md
@@ -1,3 +1,45 @@
-* No changes.
+*   `attribute_changed?` now accepts parameters which check the old and new value of the attribute
+
+    `model.name_changed?(from: "Pete", to: "Ringo")`
+
+    *Tejas Dinkar*
+
+*   Fix `has_secure_password` to honor bcrypt-ruby's cost attribute.
+
+    *T.J. Schuck*
+
+*   Updated the `ActiveModel::Dirty#changed_attributes` method to be indifferent between using
+    symbols and strings as keys.
+
+    *William Myers*
+
+*   Added new API methods `reset_changes` and `changes_applied` to `ActiveModel::Dirty`
+    that control changes state. Previsously you needed to update internal
+    instance variables, but now API methods are available.
+
+    *Bogdan Gusiev*
+
+*   Fix `has_secure_password` not to trigger `password_confirmation` validations
+    if no `password_confirmation` is set.
+
+    *Vladimir Kiselev*
+
+*   `inclusion` / `exclusion` validations with ranges will only use the faster
+    `Range#cover` for numerical ranges, and the more accurate `Range#include?`
+    for non-numerical ones.
+
+    Fixes range validations like `:a..:f` that used to pass with values like `:be`.
+    Fixes #10593.
+
+    *Charles Bergeron*
+
+*   Fix regression in `has_secure_password`. When a password is set, but a
+    confirmation is an empty string, it would incorrectly save.
+
+    *Steve Klabnik* and *Phillip Calvin*
+
+*   Deprecate `Validator#setup`. This should be done manually now in the validator's constructor.
+
+    *Nick Sutterer*
 
 Please check [4-0-stable](https://github.com/rails/rails/blob/4-0-stable/activemodel/CHANGELOG.md) for previous changes.
diff --git a/activemodel/MIT-LICENSE b/activemodel/MIT-LICENSE
index 5c668d9624..d58dd9ed9b 100644
--- a/activemodel/MIT-LICENSE
+++ b/activemodel/MIT-LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2004-2013 David Heinemeier Hansson
+Copyright (c) 2004-2014 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the
diff --git a/activemodel/README.rdoc b/activemodel/README.rdoc
index a399fe9051..4c00755532 100644
--- a/activemodel/README.rdoc
+++ b/activemodel/README.rdoc
@@ -109,7 +109,7 @@ behavior out of the box:
       attr_reader   :errors
 
       def validate!
-        errors.add(:name, "can not be nil") if name.nil?
+        errors.add(:name, "cannot be nil") if name.nil?
       end
 
       def self.human_attribute_name(attr, options = {})
@@ -118,7 +118,7 @@ behavior out of the box:
     end
 
     person.errors.full_messages
-    # => ["Name can not be nil"]
+    # => ["Name cannot be nil"]
 
   {Learn more}[link:classes/ActiveModel/Errors.html]
 
diff --git a/activemodel/Rakefile b/activemodel/Rakefile
index fc5aaf9f8f..407dda2ec3 100644
--- a/activemodel/Rakefile
+++ b/activemodel/Rakefile
@@ -13,14 +13,12 @@ end
 
 namespace :test do
   task :isolated do
-    ruby = File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME'))
     Dir.glob("#{dir}/test/**/*_test.rb").all? do |file|
-      sh(ruby, '-w', "-I#{dir}/lib", "-I#{dir}/test", file)
+      sh(Gem.ruby, '-w', "-I#{dir}/lib", "-I#{dir}/test", file)
     end or raise "Failures"
   end
 end
 
-require 'rake/packagetask'
 require 'rubygems/package_task'
 
 spec = eval(File.read("#{dir}/activemodel.gemspec"))
@@ -29,7 +27,7 @@ Gem::PackageTask.new(spec) do |p|
   p.gem_spec = spec
 end
 
-desc "Release to gemcutter"
+desc "Release to rubygems"
 task :release => :package do
   require 'rake/gemcutter'
   Rake::Gemcutter::Tasks.new(spec).define
diff --git a/activemodel/activemodel.gemspec b/activemodel/activemodel.gemspec
index 51655fe3da..36e565f692 100644
--- a/activemodel/activemodel.gemspec
+++ b/activemodel/activemodel.gemspec
@@ -5,7 +5,7 @@ Gem::Specification.new do |s|
   s.name        = 'activemodel'
   s.version     = version
   s.summary     = 'A toolkit for building modeling frameworks (part of Rails).'
-  s.description = 'A toolkit for building modeling frameworks like Active Record. Rich support for attributes, callbacks, validations, observers, serialization, internationalization, and testing.'
+  s.description = 'A toolkit for building modeling frameworks like Active Record. Rich support for attributes, callbacks, validations, serialization, internationalization, and testing.'
 
   s.required_ruby_version = '>= 1.9.3'
 
@@ -20,5 +20,5 @@ Gem::Specification.new do |s|
 
   s.add_dependency 'activesupport', version
 
-  s.add_dependency 'builder', '~> 3.1.0'
+  s.add_dependency 'builder', '~> 3.1'
 end
diff --git a/activemodel/examples/validations.rb b/activemodel/examples/validations.rb
index a56ec4db39..b8e74acd5e 100644
--- a/activemodel/examples/validations.rb
+++ b/activemodel/examples/validations.rb
@@ -1,10 +1,11 @@
+require File.expand_path('../../../load_paths', __FILE__)
 require 'active_model'
 
 class Person
   include ActiveModel::Conversion
   include ActiveModel::Validations
 
-  validates_presence_of :name
+  validates :name, presence: true
 
   attr_accessor :name
 
@@ -25,5 +26,5 @@ person1 = Person.new
 p person1.valid? # => false
 p person1.errors.messages # => {:name=>["can't be blank"]}
 
-person2 = Person.new(:name => "matz")
+person2 = Person.new(name: 'matz')
 p person2.valid? # => true
diff --git a/activemodel/lib/active_model.rb b/activemodel/lib/active_model.rb
index 3bd5531356..469f137d03 100644
--- a/activemodel/lib/active_model.rb
+++ b/activemodel/lib/active_model.rb
@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2013 David Heinemeier Hansson
+# Copyright (c) 2004-2014 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -37,7 +37,6 @@ module ActiveModel
   autoload :ForbiddenAttributesProtection
   autoload :Lint
   autoload :Model
-  autoload :DeprecatedMassAssignmentSecurity
   autoload :Name, 'active_model/naming'
   autoload :Naming
   autoload :SecurePassword
diff --git a/activemodel/lib/active_model/attribute_methods.rb b/activemodel/lib/active_model/attribute_methods.rb
index 98cde8ba59..ea07c5c039 100644
--- a/activemodel/lib/active_model/attribute_methods.rb
+++ b/activemodel/lib/active_model/attribute_methods.rb
@@ -1,4 +1,5 @@
 require 'thread_safe'
+require 'mutex_m'
 
 module ActiveModel
   # Raised when an attribute is not defined.
@@ -13,11 +14,11 @@ module ActiveModel
   class MissingAttributeError < NoMethodError
   end
 
-  # == Active \Model Attribute Methods
+  # == Active \Model \Attribute \Methods
   #
-  # <tt>ActiveModel::AttributeMethods</tt> provides a way to add prefixes and
-  # suffixes to your methods as well as handling the creation of
-  # <tt>ActiveRecord::Base</tt>-like class methods such as +table_name+.
+  # Provides a way to add prefixes and suffixes to your methods as
+  # well as handling the creation of <tt>ActiveRecord::Base</tt>-like
+  # class methods such as +table_name+.
   #
   # The requirements to implement <tt>ActiveModel::AttributeMethods</tt> are to:
   #
@@ -26,7 +27,9 @@ module ActiveModel
   #   or +attribute_method_prefix+.
   # * Call +define_attribute_methods+ after the other methods are called.
   # * Define the various generic +_attribute+ methods that you have declared.
-  # * Define an +attributes+ method, see below.
+  # * Define an +attributes+ method which returns a hash with each
+  #   attribute name in your model as hash key and the attribute value as hash value.
+  #   Hash keys must be strings.
   #
   # A minimal implementation could be:
   #
@@ -41,7 +44,7 @@ module ActiveModel
   #     attr_accessor :name
   #
   #     def attributes
-  #       {'name' => @name}
+  #       { 'name' => @name }
   #     end
   #
   #     private
@@ -58,13 +61,6 @@ module ActiveModel
   #       send("#{attr}=", 'Default Name')
   #     end
   #   end
-  #
-  # Note that whenever you include <tt>ActiveModel::AttributeMethods</tt> in
-  # your class, it requires you to implement an +attributes+ method which
-  # returns a hash with each attribute name in your model as hash key and the
-  # attribute value as hash value.
-  #
-  # Hash keys must be strings.
   module AttributeMethods
     extend ActiveSupport::Concern
 
@@ -172,14 +168,14 @@ module ActiveModel
       #     private
       #
       #     def reset_attribute_to_default!(attr)
-      #       ...
+      #       send("#{attr}=", 'Default Name')
       #     end
       #   end
       #
       #   person = Person.new
       #   person.name                         # => 'Gem'
       #   person.reset_name_to_default!
-      #   person.name                         # => 'Gemma'
+      #   person.name                         # => 'Default Name'
       def attribute_method_affix(*affixes)
         self.attribute_method_matchers += affixes.map! { |affix| AttributeMethodMatcher.new prefix: affix[:prefix], suffix: affix[:suffix] }
         undefine_attribute_methods
@@ -218,6 +214,16 @@ module ActiveModel
         end
       end
 
+      # Is +new_name+ an alias?
+      def attribute_alias?(new_name)
+        attribute_aliases.key? new_name.to_s
+      end
+
+      # Returns the original name for the alias +name+
+      def attribute_alias(name)
+        attribute_aliases[name.to_s]
+      end
+
       # Declares the attributes that should be prefixed and suffixed by
       # ActiveModel::AttributeMethods.
       #
@@ -239,7 +245,7 @@ module ActiveModel
       #     private
       #
       #     def clear_attribute(attr)
-      #       ...
+      #       send("#{attr}=", nil)
       #     end
       #   end
       def define_attribute_methods(*attr_names)
@@ -322,9 +328,10 @@ module ActiveModel
         attribute_method_matchers_cache.clear
       end
 
-      # Returns true if the attribute methods defined have been generated.
       def generated_attribute_methods #:nodoc:
-        @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
+        @generated_attribute_methods ||= Module.new {
+          extend Mutex_m
+        }.tap { |mod| include mod }
       end
 
       protected
@@ -337,7 +344,7 @@ module ActiveModel
         # invoked often in a typical rails, both of which invoke the method
         # +match_attribute_method?+. The latter method iterates through an
         # array doing regular expression matches, which results in a lot of
-        # object creations. Most of the times it returns a +nil+ match. As the
+        # object creations. Most of the time it returns a +nil+ match. As the
         # match result is always the same given a +method_name+, this cache is
         # used to alleviate the GC, which ultimately also speeds up the app
         # significantly (in our case our test suite finishes 10% faster with
@@ -388,14 +395,6 @@ module ActiveModel
           AttributeMethodMatch = Struct.new(:target, :attr_name, :method_name)
 
           def initialize(options = {})
-            if options[:prefix] == '' || options[:suffix] == ''
-              message = "Specifying an empty prefix/suffix for an attribute method is no longer " \
-                        "necessary. If the un-prefixed/suffixed version of the method has not been " \
-                        "defined when `define_attribute_methods` is called, it will be defined " \
-                        "automatically."
-              ActiveSupport::Deprecation.warn message
-            end
-
             @prefix, @suffix = options.fetch(:prefix, ''), options.fetch(:suffix, '')
             @regex = /^(?:#{Regexp.escape(@prefix)})(.*)(?:#{Regexp.escape(@suffix)})$/
             @method_missing_target = "#{@prefix}attribute#{@suffix}"
diff --git a/activemodel/lib/active_model/callbacks.rb b/activemodel/lib/active_model/callbacks.rb
index 8b09f8b203..b27a39b787 100644
--- a/activemodel/lib/active_model/callbacks.rb
+++ b/activemodel/lib/active_model/callbacks.rb
@@ -30,7 +30,7 @@ module ActiveModel
   #   end
   #
   # Then in your class, you can use the +before_create+, +after_create+ and
-  # +around_create+ methods, just as you would in an Active Record module.
+  # +around_create+ methods, just as you would in an Active Record model.
   #
   #   before_create :action_before_create
   #
@@ -135,7 +135,10 @@ module ActiveModel
       klass.define_singleton_method("after_#{callback}") do |*args, &block|
         options = args.extract_options!
         options[:prepend] = true
-        options[:if] = Array(options[:if]) << "value != false"
+        conditional = ActiveSupport::Callbacks::Conditionals::Value.new { |v|
+          v != false
+        }
+        options[:if] = Array(options[:if]) << conditional
         set_callback(:"#{callback}", :after, *(args << options), &block)
       end
     end
diff --git a/activemodel/lib/active_model/conversion.rb b/activemodel/lib/active_model/conversion.rb
index 21e4eb3c86..6b0a752566 100644
--- a/activemodel/lib/active_model/conversion.rb
+++ b/activemodel/lib/active_model/conversion.rb
@@ -1,5 +1,5 @@
 module ActiveModel
-  # == Active \Model Conversion
+  # == Active \Model \Conversion
   #
   # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
   #
@@ -41,7 +41,7 @@ module ActiveModel
     end
 
     # Returns an Enumerable of all key attributes if any is set, regardless if
-    # the object is persisted or not. If there no key attributes, returns +nil+.
+    # the object is persisted or not. Returns +nil+ if there are no key attributes.
     #
     #   class Person < ActiveRecord::Base
     #   end
diff --git a/activemodel/lib/active_model/deprecated_mass_assignment_security.rb b/activemodel/lib/active_model/deprecated_mass_assignment_security.rb
deleted file mode 100644
index 1f409c87b9..0000000000
--- a/activemodel/lib/active_model/deprecated_mass_assignment_security.rb
+++ /dev/null
@@ -1,21 +0,0 @@
-module ActiveModel
-  module DeprecatedMassAssignmentSecurity # :nodoc:
-    extend ActiveSupport::Concern
-
-     module ClassMethods # :nodoc:
-       def attr_protected(*args)
-         raise "`attr_protected` is extracted out of Rails into a gem. " \
-           "Please use new recommended protection model for params" \
-           "(strong_parameters) or add `protected_attributes` to your " \
-           "Gemfile to use old one."
-       end
-
-       def attr_accessible(*args)
-         raise "`attr_accessible` is extracted out of Rails into a gem. " \
-           "Please use new recommended protection model for params" \
-           "(strong_parameters) or add `protected_attributes` to your " \
-           "Gemfile to use old one."
-       end
-     end
-  end
-end
diff --git a/activemodel/lib/active_model/dirty.rb b/activemodel/lib/active_model/dirty.rb
index cafdb946c0..58d87e6f7f 100644
--- a/activemodel/lib/active_model/dirty.rb
+++ b/activemodel/lib/active_model/dirty.rb
@@ -14,13 +14,9 @@ module ActiveModel
   #   track.
   # * Call <tt>attr_name_will_change!</tt> before each change to the tracked
   #   attribute.
-  #
-  # If you wish to also track previous changes on save or update, you need to
-  # add:
-  #
-  #   @previously_changed = changes
-  #
-  # inside of your save or update method.
+  # * Call <tt>changes_applied</tt> after the changes are persisted.
+  # * Call <tt>reset_changes</tt> when you want to reset the changes
+  #   information.
   #
   # A minimal implementation could be:
   #
@@ -39,8 +35,12 @@ module ActiveModel
   #     end
   #
   #     def save
-  #       @previously_changed = changes
-  #       @changed_attributes.clear
+  #       # do persistence work
+  #       changes_applied
+  #     end
+  #
+  #     def reload!
+  #       reset_changes
   #     end
   #   end
   #
@@ -54,6 +54,7 @@ module ActiveModel
   #   person.name = 'Bob'
   #   person.changed?       # => true
   #   person.name_changed?  # => true
+  #   person.name_changed?(from: "Uncle Bob", to: "Bob") # => true
   #   person.name_was       # => "Uncle Bob"
   #   person.name_change    # => ["Uncle Bob", "Bob"]
   #   person.name = 'Bill'
@@ -65,6 +66,12 @@ module ActiveModel
   #   person.changed?       # => false
   #   person.name_changed?  # => false
   #
+  # Reset the changes:
+  #
+  #   person.previous_changes # => {"name" => ["Uncle Bob", "Bill"]}
+  #   person.reload!
+  #   person.previous_changes # => {}
+  #
   # Assigning the same value leaves the attribute unchanged:
   #
   #   person.name = 'Bill'
@@ -129,7 +136,7 @@ module ActiveModel
     #   person.save
     #   person.previous_changes # => {"name" => ["bob", "robert"]}
     def previous_changes
-      @previously_changed
+      @previously_changed ||= {}
     end
 
     # Returns a hash of the attributes with unsaved changes indicating their original
@@ -139,14 +146,34 @@ module ActiveModel
     #   person.name = 'robert'
     #   person.changed_attributes # => {"name" => "bob"}
     def changed_attributes
-      @changed_attributes ||= {}
+      @changed_attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    # Handle <tt>*_changed?</tt> for +method_missing+.
+    def attribute_changed?(attr, options = {}) #:nodoc:
+      result = changed_attributes.include?(attr)
+      result &&= options[:to] == __send__(attr) if options.key?(:to)
+      result &&= options[:from] == changed_attributes[attr] if options.key?(:from)
+      result
+    end
+
+    # Handle <tt>*_was</tt> for +method_missing+.
+    def attribute_was(attr) # :nodoc:
+      attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
     end
 
     private
 
-      # Handle <tt>*_changed?</tt> for +method_missing+.
-      def attribute_changed?(attr)
-        changed_attributes.include?(attr)
+      # Removes current changes and makes them accessible through +previous_changes+.
+      def changes_applied
+        @previously_changed = changes
+        @changed_attributes = {}
+      end
+
+      # Removes all dirty data: current changes and previous changes
+      def reset_changes
+        @previously_changed = {}
+        @changed_attributes = {}
       end
 
       # Handle <tt>*_change</tt> for +method_missing+.
@@ -154,11 +181,6 @@ module ActiveModel
         [changed_attributes[attr], __send__(attr)] if attribute_changed?(attr)
       end
 
-      # Handle <tt>*_was</tt> for +method_missing+.
-      def attribute_was(attr)
-        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
-      end
-
       # Handle <tt>*_will_change!</tt> for +method_missing+.
       def attribute_will_change!(attr)
         return if attribute_changed?(attr)
diff --git a/activemodel/lib/active_model/errors.rb b/activemodel/lib/active_model/errors.rb
index 0d7efab04b..010c4bb6f9 100644
--- a/activemodel/lib/active_model/errors.rb
+++ b/activemodel/lib/active_model/errors.rb
@@ -7,7 +7,7 @@ module ActiveModel
   # == Active \Model \Errors
   #
   # Provides a modified +Hash+ that you can include in your object
-  # for handling error messages and interacting with Action Pack helpers.
+  # for handling error messages and interacting with Action View helpers.
   #
   # A minimal implementation could be:
   #
@@ -23,7 +23,7 @@ module ActiveModel
   #     attr_reader   :errors
   #
   #     def validate!
-  #       errors.add(:name, "can not be nil") if name == nil
+  #       errors.add(:name, "cannot be nil") if name == nil
   #     end
   #
   #     # The following methods are needed to be minimally implemented
@@ -50,9 +50,9 @@ module ActiveModel
   #
   # The above allows you to do:
   #
-  #   p = Person.new
-  #   person.validate!            # => ["can not be nil"]
-  #   person.errors.full_messages # => ["name can not be nil"]
+  #   person = Person.new
+  #   person.validate!            # => ["cannot be nil"]
+  #   person.errors.full_messages # => ["name cannot be nil"]
   #   # etc..
   class Errors
     include Enumerable
@@ -80,7 +80,7 @@ module ActiveModel
 
     # Clear the error messages.
     #
-    #   person.errors.full_messages # => ["name can not be nil"]
+    #   person.errors.full_messages # => ["name cannot be nil"]
     #   person.errors.clear
     #   person.errors.full_messages # => []
     def clear
@@ -90,7 +90,7 @@ module ActiveModel
     # Returns +true+ if the error messages include an error for the given key
     # +attribute+, +false+ otherwise.
     #
-    #   person.errors.messages        # => {:name=>["can not be nil"]}
+    #   person.errors.messages        # => {:name=>["cannot be nil"]}
     #   person.errors.include?(:name) # => true
     #   person.errors.include?(:age)  # => false
     def include?(attribute)
@@ -101,8 +101,8 @@ module ActiveModel
 
     # Get messages for +key+.
     #
-    #   person.errors.messages   # => {:name=>["can not be nil"]}
-    #   person.errors.get(:name) # => ["can not be nil"]
+    #   person.errors.messages   # => {:name=>["cannot be nil"]}
+    #   person.errors.get(:name) # => ["cannot be nil"]
     #   person.errors.get(:age)  # => nil
     def get(key)
       messages[key]
@@ -110,7 +110,7 @@ module ActiveModel
 
     # Set messages for +key+ to +value+.
     #
-    #   person.errors.get(:name) # => ["can not be nil"]
+    #   person.errors.get(:name) # => ["cannot be nil"]
     #   person.errors.set(:name, ["can't be nil"])
     #   person.errors.get(:name) # => ["can't be nil"]
     def set(key, value)
@@ -119,8 +119,8 @@ module ActiveModel
 
     # Delete messages for +key+. Returns the deleted messages.
     #
-    #   person.errors.get(:name)    # => ["can not be nil"]
-    #   person.errors.delete(:name) # => ["can not be nil"]
+    #   person.errors.get(:name)    # => ["cannot be nil"]
+    #   person.errors.delete(:name) # => ["cannot be nil"]
     #   person.errors.get(:name)    # => nil
     def delete(key)
       messages.delete(key)
@@ -129,8 +129,8 @@ module ActiveModel
     # When passed a symbol or a name of a method, returns an array of errors
     # for the method.
     #
-    #   person.errors[:name]  # => ["can not be nil"]
-    #   person.errors['name'] # => ["can not be nil"]
+    #   person.errors[:name]  # => ["cannot be nil"]
+    #   person.errors['name'] # => ["cannot be nil"]
     def [](attribute)
       get(attribute.to_sym) || set(attribute.to_sym, [])
     end
@@ -175,15 +175,15 @@ module ActiveModel
 
     # Returns all message values.
     #
-    #   person.errors.messages # => {:name=>["can not be nil", "must be specified"]}
-    #   person.errors.values   # => [["can not be nil", "must be specified"]]
+    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
+    #   person.errors.values   # => [["cannot be nil", "must be specified"]]
     def values
       messages.values
     end
 
     # Returns all message keys.
     #
-    #   person.errors.messages # => {:name=>["can not be nil", "must be specified"]}
+    #   person.errors.messages # => {:name=>["cannot be nil", "must be specified"]}
     #   person.errors.keys     # => [:name]
     def keys
       messages.keys
@@ -211,7 +211,7 @@ module ActiveModel
     # Returns +true+ if no errors are found, +false+ otherwise.
     # If the error message is a string it can be empty.
     #
-    #   person.errors.full_messages # => ["name can not be nil"]
+    #   person.errors.full_messages # => ["name cannot be nil"]
     #   person.errors.empty?        # => false
     def empty?
       all? { |k, v| v && v.empty? && !v.is_a?(String) }
@@ -238,8 +238,8 @@ module ActiveModel
     # object. You can pass the <tt>:full_messages</tt> option. This determines
     # if the json object should contain full messages or not (false by default).
     #
-    #   person.as_json                      # => {:name=>["can not be nil"]}
-    #   person.as_json(full_messages: true) # => {:name=>["name can not be nil"]}
+    #   person.errors.as_json                      # => {:name=>["cannot be nil"]}
+    #   person.errors.as_json(full_messages: true) # => {:name=>["name cannot be nil"]}
     def as_json(options=nil)
       to_hash(options && options[:full_messages])
     end
@@ -247,8 +247,8 @@ module ActiveModel
     # Returns a Hash of attributes with their error messages. If +full_messages+
     # is +true+, it will contain full messages (see +full_message+).
     #
-    #   person.to_hash       # => {:name=>["can not be nil"]}
-    #   person.to_hash(true) # => {:name=>["name can not be nil"]}
+    #   person.errors.to_hash       # => {:name=>["cannot be nil"]}
+    #   person.errors.to_hash(true) # => {:name=>["name cannot be nil"]}
     def to_hash(full_messages = false)
       if full_messages
         messages = {}
@@ -279,7 +279,7 @@ module ActiveModel
     # If +message+ is a proc, it will be called, allowing for things like
     # <tt>Time.now</tt> to be used within an error.
     #
-    # If the <tt>:strict</tt> option is set to true will raise
+    # If the <tt>:strict</tt> option is set to +true+, it will raise
     # ActiveModel::StrictValidationFailed instead of adding the error.
     # <tt>:strict</tt> option can also be set to any other exception.
     #
@@ -289,7 +289,7 @@ module ActiveModel
     #   # => NameIsInvalid: name is invalid
     #
     #   person.errors.messages # => {}
-    def add(attribute, message = nil, options = {})
+    def add(attribute, message = :invalid, options = {})
       message = normalize_message(attribute, message, options)
       if exception = options[:strict]
         exception = ActiveModel::StrictValidationFailed if exception == true
@@ -331,7 +331,7 @@ module ActiveModel
     #
     #   person.errors.add :name, :blank
     #   person.errors.added? :name, :blank # => true
-    def added?(attribute, message = nil, options = {})
+    def added?(attribute, message = :invalid, options = {})
       message = normalize_message(attribute, message, options)
       self[attribute].include? message
     end
@@ -437,8 +437,6 @@ module ActiveModel
 
   private
     def normalize_message(attribute, message, options)
-      message ||= :invalid
-
       case message
       when Symbol
         generate_message(attribute, message, options.except(*CALLBACKS_OPTIONS))
diff --git a/activemodel/lib/active_model/lint.rb b/activemodel/lib/active_model/lint.rb
index 46b446dc08..c6bc18b008 100644
--- a/activemodel/lib/active_model/lint.rb
+++ b/activemodel/lib/active_model/lint.rb
@@ -13,7 +13,7 @@ module ActiveModel
     #
     # These tests do not attempt to determine the semantic correctness of the
     # returned values. For instance, you could implement <tt>valid?</tt> to
-    # always return true, and the tests would pass. It is up to you to ensure
+    # always return +true+, and the tests would pass. It is up to you to ensure
     # that the values are semantically meaningful.
     #
     # Objects you pass in are expected to return a compliant object from a call
diff --git a/activemodel/lib/active_model/model.rb b/activemodel/lib/active_model/model.rb
index 62383a03e8..63716eebb1 100644
--- a/activemodel/lib/active_model/model.rb
+++ b/activemodel/lib/active_model/model.rb
@@ -1,6 +1,6 @@
 module ActiveModel
 
-  # == Active \Model Basic \Model
+  # == Active \Model \Basic \Model
   #
   # Includes the required interface for an object to interact with
   # <tt>ActionPack</tt>, using different <tt>ActiveModel</tt> modules.
@@ -79,6 +79,8 @@ module ActiveModel
       params.each do |attr, value|
         self.public_send("#{attr}=", value)
       end if params
+
+      super()
     end
 
     # Indicates if the model is persisted. Default is +false+.
diff --git a/activemodel/lib/active_model/naming.rb b/activemodel/lib/active_model/naming.rb
index bc9edf4a56..11ebfe6cc0 100644
--- a/activemodel/lib/active_model/naming.rb
+++ b/activemodel/lib/active_model/naming.rb
@@ -262,10 +262,10 @@ module ActiveModel
     # namespaced models regarding whether it's inside isolated engine.
     #
     #   # For isolated engine:
-    #   ActiveModel::Naming.singular_route_key(Blog::Post) #=> post
+    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "post"
     #
     #   # For shared engine:
-    #   ActiveModel::Naming.singular_route_key(Blog::Post) #=> blog_post
+    #   ActiveModel::Naming.singular_route_key(Blog::Post) # => "blog_post"
     def self.singular_route_key(record_or_class)
       model_name_from_record_or_class(record_or_class).singular_route_key
     end
@@ -274,10 +274,10 @@ module ActiveModel
     # namespaced models regarding whether it's inside isolated engine.
     #
     #   # For isolated engine:
-    #   ActiveModel::Naming.route_key(Blog::Post) #=> posts
+    #   ActiveModel::Naming.route_key(Blog::Post) # => "posts"
     #
     #   # For shared engine:
-    #   ActiveModel::Naming.route_key(Blog::Post) #=> blog_posts
+    #   ActiveModel::Naming.route_key(Blog::Post) # => "blog_posts"
     #
     # The route key also considers if the noun is uncountable and, in
     # such cases, automatically appends _index.
@@ -289,10 +289,10 @@ module ActiveModel
     # namespaced models regarding whether it's inside isolated engine.
     #
     #   # For isolated engine:
-    #   ActiveModel::Naming.param_key(Blog::Post) #=> post
+    #   ActiveModel::Naming.param_key(Blog::Post) # => "post"
     #
     #   # For shared engine:
-    #   ActiveModel::Naming.param_key(Blog::Post) #=> blog_post
+    #   ActiveModel::Naming.param_key(Blog::Post) # => "blog_post"
     def self.param_key(record_or_class)
       model_name_from_record_or_class(record_or_class).param_key
     end
diff --git a/activemodel/lib/active_model/secure_password.rb b/activemodel/lib/active_model/secure_password.rb
index 750fd723a0..d824a66784 100644
--- a/activemodel/lib/active_model/secure_password.rb
+++ b/activemodel/lib/active_model/secure_password.rb
@@ -2,12 +2,14 @@ module ActiveModel
   module SecurePassword
     extend ActiveSupport::Concern
 
-    class << self; attr_accessor :min_cost; end
+    class << self
+      attr_accessor :min_cost # :nodoc:
+    end
     self.min_cost = false
 
     module ClassMethods
       # Adds methods to set and authenticate against a BCrypt password.
-      # This mechanism requires you to have a password_digest attribute.
+      # This mechanism requires you to have a +password_digest+ attribute.
       #
       # Validations for presence of password on create, confirmation of password
       # (using a +password_confirmation+ attribute) are automatically added. If
@@ -15,12 +17,12 @@ module ActiveModel
       # argument. You can add more validations by hand if need be.
       #
       # If you don't need the confirmation validation, just don't set any
-      # value to the password_confirmation attribute and the the validation
+      # value to the password_confirmation attribute and the validation
       # will not be triggered.
       #
-      # You need to add bcrypt-ruby (~> 3.0.0) to Gemfile to use #has_secure_password:
+      # You need to add bcrypt-ruby (~> 3.1.2) to Gemfile to use #has_secure_password:
       #
-      #   gem 'bcrypt-ruby', '~> 3.0.0'
+      #   gem 'bcrypt-ruby', '~> 3.1.2'
       #
       # Example using Active Record (which automatically includes ActiveModel::SecurePassword):
       #
@@ -44,7 +46,6 @@ module ActiveModel
         # This is to avoid ActiveModel (and by extension the entire framework)
         # being dependent on a binary library.
         begin
-          gem 'bcrypt-ruby', '~> 3.0.0'
           require 'bcrypt'
         rescue LoadError
           $stderr.puts "You don't have bcrypt-ruby installed in your application. Please add it to your Gemfile and run bundle install"
@@ -56,8 +57,9 @@ module ActiveModel
         include InstanceMethodsOnActivation
 
         if options.fetch(:validations, true)
-          validates_confirmation_of :password
+          validates_confirmation_of :password, if: :password_confirmation_required?
           validates_presence_of     :password, on: :create
+          validates_presence_of     :password_confirmation, if: :password_confirmation_required?
 
           before_create { raise "Password digest missing on new record" if password_digest.blank? }
         end
@@ -100,16 +102,20 @@ module ActiveModel
       def password=(unencrypted_password)
         unless unencrypted_password.blank?
           @password = unencrypted_password
-          cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine::DEFAULT_COST
+          cost = ActiveModel::SecurePassword.min_cost ? BCrypt::Engine::MIN_COST : BCrypt::Engine.cost
           self.password_digest = BCrypt::Password.create(unencrypted_password, cost: cost)
         end
       end
 
       def password_confirmation=(unencrypted_password)
-        unless unencrypted_password.blank?
-          @password_confirmation = unencrypted_password
-        end
+        @password_confirmation = unencrypted_password
       end
+
+      private
+
+        def password_confirmation_required?
+          password_confirmation && password.present?
+        end
     end
   end
 end
diff --git a/activemodel/lib/active_model/serialization.rb b/activemodel/lib/active_model/serialization.rb
index fdb06aebb9..36a6c00290 100644
--- a/activemodel/lib/active_model/serialization.rb
+++ b/activemodel/lib/active_model/serialization.rb
@@ -128,7 +128,7 @@ module ActiveModel
       # retrieve the value for a given attribute differently:
       #
       #   class MyClass
-      #     include ActiveModel::Validations
+      #     include ActiveModel::Serialization
       #
       #     def initialize(data = {})
       #       @data = data
diff --git a/activemodel/lib/active_model/serializers/json.rb b/activemodel/lib/active_model/serializers/json.rb
index 9d984b7a18..c58e73f6a7 100644
--- a/activemodel/lib/active_model/serializers/json.rb
+++ b/activemodel/lib/active_model/serializers/json.rb
@@ -2,7 +2,7 @@ require 'active_support/json'
 
 module ActiveModel
   module Serializers
-    # == Active Model JSON Serializer
+    # == Active \Model \JSON \Serializer
     module JSON
       extend ActiveSupport::Concern
       include ActiveModel::Serialization
@@ -109,7 +109,7 @@ module ActiveModel
       #
       #     def attributes=(hash)
       #       hash.each do |key, value|
-      #         instance_variable_set("@#{key}", value)
+      #         send("#{key}=", value)
       #       end
       #     end
       #
diff --git a/activemodel/lib/active_model/serializers/xml.rb b/activemodel/lib/active_model/serializers/xml.rb
index 2803f69b6f..7f99536dbb 100644
--- a/activemodel/lib/active_model/serializers/xml.rb
+++ b/activemodel/lib/active_model/serializers/xml.rb
@@ -1,4 +1,4 @@
-require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/hash/conversions'
 require 'active_support/core_ext/hash/slice'
@@ -205,7 +205,7 @@ module ActiveModel
         Serializer.new(self, options).serialize(&block)
       end
 
-      # Sets the model +attributes+ from a JSON string. Returns +self+.
+      # Sets the model +attributes+ from an XML string. Returns +self+.
       #
       #   class Person
       #     include ActiveModel::Serializers::Xml
diff --git a/activemodel/lib/active_model/validations.rb b/activemodel/lib/active_model/validations.rb
index 92206450d2..6be44b5d63 100644
--- a/activemodel/lib/active_model/validations.rb
+++ b/activemodel/lib/active_model/validations.rb
@@ -4,7 +4,7 @@ require 'active_support/core_ext/hash/except'
 
 module ActiveModel
 
-  # == Active \Model Validations
+  # == Active \Model \Validations
   #
   # Provides a full validation framework to your objects.
   #
@@ -142,7 +142,9 @@ module ActiveModel
         if options.key?(:on)
           options = options.dup
           options[:if] = Array(options[:if])
-          options[:if].unshift("validation_context == :#{options[:on]}")
+          options[:if].unshift lambda { |o|
+            o.validation_context == options[:on]
+          }
         end
         args << options
         set_callback(:validate, *args, &block)
@@ -226,7 +228,6 @@ module ActiveModel
       #   Person.validators_on(:name)
       #   # => [
       #   #       #<ActiveModel::Validations::PresenceValidator:0x007fe604914e60 @attributes=[:name], @options={}>,
-      #   #       #<ActiveModel::Validations::InclusionValidator:0x007fe603bb8780 @attributes=[:age], @options={in:0..99}>
       #   #    ]
       def validators_on(*attributes)
         attributes.flat_map do |attribute|
diff --git a/activemodel/lib/active_model/validations/acceptance.rb b/activemodel/lib/active_model/validations/acceptance.rb
index 78e6f67a47..139de16326 100644
--- a/activemodel/lib/active_model/validations/acceptance.rb
+++ b/activemodel/lib/active_model/validations/acceptance.rb
@@ -4,6 +4,7 @@ module ActiveModel
     class AcceptanceValidator < EachValidator # :nodoc:
       def initialize(options)
         super({ allow_nil: true, accept: "1" }.merge!(options))
+        setup!(options[:class])
       end
 
       def validate_each(record, attribute, value)
@@ -12,7 +13,8 @@ module ActiveModel
         end
       end
 
-      def setup(klass)
+      private
+      def setup!(klass)
         attr_readers = attributes.reject { |name| klass.attribute_method?(name) }
         attr_writers = attributes.reject { |name| klass.attribute_method?("#{name}=") }
         klass.send(:attr_reader, *attr_readers)
diff --git a/activemodel/lib/active_model/validations/callbacks.rb b/activemodel/lib/active_model/validations/callbacks.rb
index cabb9482f2..edfffdd3ce 100644
--- a/activemodel/lib/active_model/validations/callbacks.rb
+++ b/activemodel/lib/active_model/validations/callbacks.rb
@@ -1,6 +1,6 @@
 module ActiveModel
   module Validations
-    # == Active \Model Validation Callbacks
+    # == Active \Model \Validation \Callbacks
     #
     # Provides an interface for any class to have +before_validation+ and
     # +after_validation+ callbacks.
@@ -58,7 +58,9 @@ module ActiveModel
           if options.is_a?(Hash) && options[:on]
             options[:if] = Array(options[:if])
             options[:on] = Array(options[:on])
-            options[:if].unshift("#{options[:on]}.include? self.validation_context")
+            options[:if].unshift lambda { |o|
+              options[:on].include? o.validation_context
+            }
           end
           set_callback(:validation, :before, *args, &block)
         end
diff --git a/activemodel/lib/active_model/validations/clusivity.rb b/activemodel/lib/active_model/validations/clusivity.rb
index 49df98d6c1..bad9e4f9a9 100644
--- a/activemodel/lib/active_model/validations/clusivity.rb
+++ b/activemodel/lib/active_model/validations/clusivity.rb
@@ -15,26 +15,36 @@ module ActiveModel
     private
 
       def include?(record, value)
-        exclusions = if delimiter.respond_to?(:call)
-                       delimiter.call(record)
-                     elsif delimiter.respond_to?(:to_sym)
-                       record.send(delimiter)
-                     else
-                       delimiter
-                     end
+        members = if delimiter.respond_to?(:call)
+                    delimiter.call(record)
+                  elsif delimiter.respond_to?(:to_sym)
+                    record.send(delimiter)
+                  else
+                    delimiter
+                  end
 
-        exclusions.send(inclusion_method(exclusions), value)
+        members.send(inclusion_method(members), value)
       end
 
       def delimiter
         @delimiter ||= options[:in] || options[:within]
       end
 
-      # In Ruby 1.9 <tt>Range#include?</tt> on non-numeric ranges checks all possible values in the
-      # range for equality, so it may be slow for large ranges. The new <tt>Range#cover?</tt>
-      # uses the previous logic of comparing a value with the range endpoints.
+      # In Ruby 1.9 <tt>Range#include?</tt> on non-number-or-time-ish ranges checks all
+      # possible values in the range for equality, which is slower but more accurate.
+      # <tt>Range#cover?</tt> uses the previous logic of comparing a value with the range
+      # endpoints, which is fast but is only accurate on Numeric, Time, or DateTime ranges.
       def inclusion_method(enumerable)
-        enumerable.is_a?(Range) ? :cover? : :include?
+        if enumerable.is_a? Range
+          case enumerable.first
+          when Numeric, Time, DateTime
+            :cover?
+          else
+            :include?
+          end
+        else
+          :include?
+        end
       end
     end
   end
diff --git a/activemodel/lib/active_model/validations/confirmation.rb b/activemodel/lib/active_model/validations/confirmation.rb
index 1d85378892..b0542661af 100644
--- a/activemodel/lib/active_model/validations/confirmation.rb
+++ b/activemodel/lib/active_model/validations/confirmation.rb
@@ -2,6 +2,11 @@ module ActiveModel
 
   module Validations
     class ConfirmationValidator < EachValidator # :nodoc:
+      def initialize(options)
+        super
+        setup!(options[:class])
+      end
+
       def validate_each(record, attribute, value)
         if (confirmed = record.send("#{attribute}_confirmation")) && (value != confirmed)
           human_attribute_name = record.class.human_attribute_name(attribute)
@@ -9,7 +14,8 @@ module ActiveModel
         end
       end
 
-      def setup(klass)
+      private
+      def setup!(klass)
         klass.send(:attr_reader, *attributes.map do |attribute|
           :"#{attribute}_confirmation" unless klass.method_defined?(:"#{attribute}_confirmation")
         end.compact)
diff --git a/activemodel/lib/active_model/validations/format.rb b/activemodel/lib/active_model/validations/format.rb
index be7cae588f..f0fe22438f 100644
--- a/activemodel/lib/active_model/validations/format.rb
+++ b/activemodel/lib/active_model/validations/format.rb
@@ -17,8 +17,8 @@ module ActiveModel
           raise ArgumentError, "Either :with or :without must be supplied (but not both)"
         end
 
-        check_options_validity(options, :with)
-        check_options_validity(options, :without)
+        check_options_validity :with
+        check_options_validity :without
       end
 
       private
@@ -32,21 +32,23 @@ module ActiveModel
         record.errors.add(attribute, :invalid, options.except(name).merge!(value: value))
       end
 
-      def regexp_using_multiline_anchors?(regexp)
-        regexp.source.start_with?("^") ||
-          (regexp.source.end_with?("$") && !regexp.source.end_with?("\\$"))
+      def check_options_validity(name)
+        if option = options[name]
+          if option.is_a?(Regexp)
+            if options[:multiline] != true && regexp_using_multiline_anchors?(option)
+              raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
+              "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
+              ":multiline => true option?"
+            end
+          elsif !option.respond_to?(:call)
+            raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
+          end
+        end
       end
 
-      def check_options_validity(options, name)
-        option = options[name]
-        if option && !option.is_a?(Regexp) && !option.respond_to?(:call)
-          raise ArgumentError, "A regular expression or a proc or lambda must be supplied as :#{name}"
-        elsif option && option.is_a?(Regexp) &&
-              regexp_using_multiline_anchors?(option) && options[:multiline] != true
-          raise ArgumentError, "The provided regular expression is using multiline anchors (^ or $), " \
-          "which may present a security risk. Did you mean to use \\A and \\z, or forgot to add the " \
-          ":multiline => true option?"
-        end
+      def regexp_using_multiline_anchors?(regexp)
+        source = regexp.source
+        source.start_with?("^") || (source.end_with?("$") && !source.end_with?("\\$"))
       end
     end
 
diff --git a/activemodel/lib/active_model/validations/inclusion.rb b/activemodel/lib/active_model/validations/inclusion.rb
index 1cfd86efee..24337614c5 100644
--- a/activemodel/lib/active_model/validations/inclusion.rb
+++ b/activemodel/lib/active_model/validations/inclusion.rb
@@ -28,7 +28,7 @@ module ActiveModel
       # Configuration options:
       # * <tt>:in</tt> - An enumerable object of available items. This can be
       #   supplied as a proc, lambda or symbol which returns an enumerable. If the
-      #   enumerable is a range the test is performed with <tt>Range#cover?</tt>,
+      #   enumerable is a numerical range the test is performed with <tt>Range#cover?</tt>,
       #   otherwise with <tt>include?</tt>.
       # * <tt>:within</tt> - A synonym(or alias) for <tt>:in</tt>
       # * <tt>:message</tt> - Specifies a custom error message (default is: "is
diff --git a/activemodel/lib/active_model/validations/length.rb b/activemodel/lib/active_model/validations/length.rb
index ddfd8a342e..a96b30cadd 100644
--- a/activemodel/lib/active_model/validations/length.rb
+++ b/activemodel/lib/active_model/validations/length.rb
@@ -1,6 +1,6 @@
 module ActiveModel
 
-  # == Active \Model Length \Validator
+  # == Active \Model Length Validator
   module Validations
     class LengthValidator < EachValidator # :nodoc:
       MESSAGES  = { is: :wrong_length, minimum: :too_short, maximum: :too_long }.freeze
diff --git a/activemodel/lib/active_model/validations/numericality.rb b/activemodel/lib/active_model/validations/numericality.rb
index c6abe45f4a..c8d3236463 100644
--- a/activemodel/lib/active_model/validations/numericality.rb
+++ b/activemodel/lib/active_model/validations/numericality.rb
@@ -11,8 +11,9 @@ module ActiveModel
       def check_validity!
         keys = CHECKS.keys - [:odd, :even]
         options.slice(*keys).each do |option, value|
-          next if value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
-          raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
+          unless value.is_a?(Numeric) || value.is_a?(Proc) || value.is_a?(Symbol)
+            raise ArgumentError, ":#{option} must be a number, a symbol or a proc"
+          end
         end
       end
 
@@ -43,11 +44,15 @@ module ActiveModel
               record.errors.add(attr_name, option, filtered_options(value))
             end
           else
-            option_value = option_value.call(record) if option_value.is_a?(Proc)
-            option_value = record.send(option_value) if option_value.is_a?(Symbol)
+            case option_value
+            when Proc
+              option_value = option_value.call(record)
+            when Symbol
+              option_value = record.send(option_value)
+            end
 
             unless value.send(CHECKS[option], option_value)
-              record.errors.add(attr_name, option, filtered_options(value).merge(count: option_value))
+              record.errors.add(attr_name, option, filtered_options(value).merge!(count: option_value))
             end
           end
         end
@@ -56,16 +61,9 @@ module ActiveModel
     protected
 
       def parse_raw_value_as_a_number(raw_value)
-        case raw_value
-        when /\A0[xX]/
-          nil
-        else
-          begin
-            Kernel.Float(raw_value)
-          rescue ArgumentError, TypeError
-            nil
-          end
-        end
+        Kernel.Float(raw_value) if raw_value !~ /\A0[xX]/
+      rescue ArgumentError, TypeError
+        nil
       end
 
       def parse_raw_value_as_an_integer(raw_value)
@@ -73,7 +71,9 @@ module ActiveModel
       end
 
       def filtered_options(value)
-        options.except(*RESERVED_OPTIONS).merge!(value: value)
+        filtered = options.except(*RESERVED_OPTIONS)
+        filtered[:value] = value
+        filtered
       end
     end
 
diff --git a/activemodel/lib/active_model/validations/validates.rb b/activemodel/lib/active_model/validations/validates.rb
index 9a1ff2ad39..bf588b7bd0 100644
--- a/activemodel/lib/active_model/validations/validates.rb
+++ b/activemodel/lib/active_model/validations/validates.rb
@@ -13,7 +13,7 @@ module ActiveModel
       #   validates :terms, acceptance: true
       #   validates :password, confirmation: true
       #   validates :username, exclusion: { in: %w(admin superuser) }
-      #   validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i, on: :create }
+      #   validates :email, format: { with: /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\z/i, on: :create }
       #   validates :age, inclusion: { in: 0..9 }
       #   validates :first_name, length: { maximum: 30 }
       #   validates :age, numericality: true
diff --git a/activemodel/lib/active_model/validations/with.rb b/activemodel/lib/active_model/validations/with.rb
index 2ae335d0f4..16bd6670d1 100644
--- a/activemodel/lib/active_model/validations/with.rb
+++ b/activemodel/lib/active_model/validations/with.rb
@@ -83,9 +83,10 @@ module ActiveModel
       #   end
       def validates_with(*args, &block)
         options = args.extract_options!
+        options[:class] = self
+
         args.each do |klass|
           validator = klass.new(options, &block)
-          validator.setup(self) if validator.respond_to?(:setup)
 
           if validator.respond_to?(:attributes) && !validator.attributes.empty?
             validator.attributes.each do |attribute|
diff --git a/activemodel/lib/active_model/validator.rb b/activemodel/lib/active_model/validator.rb
index 037650e5ac..bddacc8c45 100644
--- a/activemodel/lib/active_model/validator.rb
+++ b/activemodel/lib/active_model/validator.rb
@@ -61,7 +61,7 @@ module ActiveModel
   #   end
   #
   # Note that the validator is initialized only once for the whole application
-  # lifecycle, and not on each validation run.
+  # life cycle, and not on each validation run.
   #
   # The easiest way to add custom validators for validating individual attributes
   # is with the convenient <tt>ActiveModel::EachValidator</tt>.
@@ -82,18 +82,16 @@ module ActiveModel
   #     validates :title, presence: true
   #   end
   #
-  # Validator may also define a +setup+ instance method which will get called
-  # with the class that using that validator as its argument. This can be
-  # useful when there are prerequisites such as an +attr_accessor+ being present.
+  # It can be useful to access the class that is using that validator when there are prerequisites such
+  # as an +attr_accessor+ being present. This class is accessible via +options[:class]+ in the constructor.
+  # To setup your validator override the constructor.
   #
   #   class MyValidator < ActiveModel::Validator
-  #     def setup(klass)
-  #       klass.send :attr_accessor, :custom_attribute
+  #     def initialize(options={})
+  #       super
+  #       options[:class].send :attr_accessor, :custom_attribute
   #     end
   #   end
-  #
-  # This setup method is only called when used with validation macros or the
-  # class level <tt>validates_with</tt> method.
   class Validator
     attr_reader :options
 
@@ -107,10 +105,11 @@ module ActiveModel
 
     # Accepts options that will be made available through the +options+ reader.
     def initialize(options = {})
-      @options = options.freeze
+      @options  = options.except(:class).freeze
+      deprecated_setup(options)
     end
 
-    # Return the kind for this validator.
+    # Returns the kind for this validator.
     #
     #   PresenceValidator.new.kind   # => :presence
     #   UniquenessValidator.new.kind # => :uniqueness
@@ -123,6 +122,21 @@ module ActiveModel
     def validate(record)
       raise NotImplementedError, "Subclasses must implement a validate(record) method."
     end
+
+    private
+    def deprecated_setup(options) # TODO: remove me in 4.2.
+      return unless respond_to?(:setup)
+      ActiveSupport::Deprecation.warn "The `Validator#setup` instance method is deprecated and will be removed on Rails 4.2. Do your setup in the constructor instead:
+
+class MyValidator < ActiveModel::Validator
+  def initialize(options={})
+    super
+    options[:class].send :attr_accessor, :custom_attribute
+  end
+end
+"
+      setup(options[:class])
+    end
   end
 
   # +EachValidator+ is a validator which iterates through the attributes given
diff --git a/activemodel/lib/active_model/version.rb b/activemodel/lib/active_model/version.rb
index 86340bba37..58ba3ab9b2 100644
--- a/activemodel/lib/active_model/version.rb
+++ b/activemodel/lib/active_model/version.rb
@@ -1,7 +1,7 @@
 module ActiveModel
   # Returns the version of the currently loaded ActiveModel as a Gem::Version
   def self.version
-    Gem::Version.new "4.1.0.beta"
+    Gem::Version.new "4.1.0.beta1"
   end
 
   module VERSION #:nodoc:
diff --git a/activemodel/test/cases/attribute_methods_test.rb b/activemodel/test/cases/attribute_methods_test.rb
index 25eb4860e3..e9cb5ccc96 100644
--- a/activemodel/test/cases/attribute_methods_test.rb
+++ b/activemodel/test/cases/attribute_methods_test.rb
@@ -202,17 +202,6 @@ class AttributeMethodsTest < ActiveModel::TestCase
     assert_equal 'bar', m.foo_test
   end
 
-  test 'explicitly specifying an empty prefix/suffix is deprecated' do
-    klass = Class.new(ModelWithAttributes)
-
-    assert_deprecated { klass.attribute_method_suffix '' }
-    assert_deprecated { klass.attribute_method_prefix '' }
-
-    klass.define_attribute_methods(:foo)
-
-    assert_equal 'value of foo', klass.new.foo
-  end
-
   test 'should not interfere with method_missing if the attr has a private/protected method' do
     m = ModelWithAttributes2.new
     m.attributes = { 'private_method' => '<3', 'protected_method' => 'O_o' }
diff --git a/activemodel/test/cases/deprecated_mass_assignment_security_test.rb b/activemodel/test/cases/deprecated_mass_assignment_security_test.rb
deleted file mode 100644
index c1fe8822cd..0000000000
--- a/activemodel/test/cases/deprecated_mass_assignment_security_test.rb
+++ /dev/null
@@ -1,16 +0,0 @@
-require 'cases/helper'
-require 'models/project'
-
-class DeprecatedMassAssignmentSecurityTest < ActiveModel::TestCase
-  def test_attr_accessible_raise_error
-    assert_raise RuntimeError, /protected_attributes/ do
-      Project.attr_accessible :username
-    end
-  end
-
-  def test_attr_protected_raise_error
-    assert_raise RuntimeError, /protected_attributes/ do
-      Project.attr_protected :username
-    end
-  end
-end
diff --git a/activemodel/test/cases/dirty_test.rb b/activemodel/test/cases/dirty_test.rb
index ba45089cca..54427a1513 100644
--- a/activemodel/test/cases/dirty_test.rb
+++ b/activemodel/test/cases/dirty_test.rb
@@ -3,11 +3,12 @@ require "cases/helper"
 class DirtyTest < ActiveModel::TestCase
   class DirtyModel
     include ActiveModel::Dirty
-    define_attribute_methods :name, :color
+    define_attribute_methods :name, :color, :size
 
     def initialize
       @name = nil
       @color = nil
+      @size = nil
     end
 
     def name
@@ -28,9 +29,17 @@ class DirtyTest < ActiveModel::TestCase
       @color = val
     end
 
+    def size
+      @size
+    end
+
+    def size=(val)
+      attribute_will_change!(:size) unless val == @size
+      @size = val
+    end
+
     def save
-      @previously_changed = changes
-      @changed_attributes.clear
+      changes_applied
     end
   end
 
@@ -58,6 +67,16 @@ class DirtyTest < ActiveModel::TestCase
     assert_equal [nil, "John"], @model.changes['name']
   end
 
+  test "checking if an attribute has changed to a particular value" do
+    @model.name = "Ringo"
+    assert @model.name_changed?(from: nil, to: "Ringo")
+    assert_not @model.name_changed?(from: "Pete", to: "Ringo")
+    assert @model.name_changed?(to: "Ringo")
+    assert_not @model.name_changed?(to: "Pete")
+    assert @model.name_changed?(from: nil)
+    assert_not @model.name_changed?(from: "Pete")
+  end
+
   test "changes accessible through both strings and symbols" do
     @model.name = "David"
     assert_not_nil @model.changes[:name]
@@ -125,4 +144,9 @@ class DirtyTest < ActiveModel::TestCase
     assert_equal ["Otto", "Mr. Manfredgensonton"], @model.name_change
     assert_equal @model.name_was, "Otto"
   end
+
+  test "using attribute_will_change! with a symbol" do
+    @model.size = 1
+    assert @model.size_changed?
+  end
 end
diff --git a/activemodel/test/cases/errors_test.rb b/activemodel/test/cases/errors_test.rb
index 4e07e0e00b..bbd186d83d 100644
--- a/activemodel/test/cases/errors_test.rb
+++ b/activemodel/test/cases/errors_test.rb
@@ -11,7 +11,7 @@ class ErrorsTest < ActiveModel::TestCase
     attr_reader   :errors
 
     def validate!
-      errors.add(:name, "can not be nil") if name == nil
+      errors.add(:name, "cannot be nil") if name == nil
     end
 
     def read_attribute_for_validation(attr)
@@ -104,8 +104,8 @@ class ErrorsTest < ActiveModel::TestCase
   test "adding errors using conditionals with Person#validate!" do
     person = Person.new
     person.validate!
-    assert_equal ["name can not be nil"], person.errors.full_messages
-    assert_equal ["can not be nil"], person.errors[:name]
+    assert_equal ["name cannot be nil"], person.errors.full_messages
+    assert_equal ["cannot be nil"], person.errors[:name]
   end
 
   test "assign error" do
@@ -116,8 +116,8 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "add an error message on a specific attribute" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    assert_equal ["can not be blank"], person.errors[:name]
+    person.errors.add(:name, "cannot be blank")
+    assert_equal ["cannot be blank"], person.errors[:name]
   end
 
   test "add an error with a symbol" do
@@ -129,15 +129,15 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "add an error with a proc" do
     person = Person.new
-    message = Proc.new { "can not be blank" }
+    message = Proc.new { "cannot be blank" }
     person.errors.add(:name, message)
-    assert_equal ["can not be blank"], person.errors[:name]
+    assert_equal ["cannot be blank"], person.errors[:name]
   end
 
   test "added? detects if a specific error was added to the object" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    assert person.errors.added?(:name, "can not be blank")
+    person.errors.add(:name, "cannot be blank")
+    assert person.errors.added?(:name, "cannot be blank")
   end
 
   test "added? handles symbol message" do
@@ -148,7 +148,7 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "added? handles proc messages" do
     person = Person.new
-    message = Proc.new { "can not be blank" }
+    message = Proc.new { "cannot be blank" }
     person.errors.add(:name, message)
     assert person.errors.added?(:name, message)
   end
@@ -161,9 +161,9 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "added? matches the given message when several errors are present for the same attribute" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
+    person.errors.add(:name, "cannot be blank")
     person.errors.add(:name, "is invalid")
-    assert person.errors.added?(:name, "can not be blank")
+    assert person.errors.added?(:name, "cannot be blank")
   end
 
   test "added? returns false when no errors are present" do
@@ -174,52 +174,52 @@ class ErrorsTest < ActiveModel::TestCase
   test "added? returns false when checking a nonexisting error and other errors are present for the given attribute" do
     person = Person.new
     person.errors.add(:name, "is invalid")
-    assert !person.errors.added?(:name, "can not be blank")
+    assert !person.errors.added?(:name, "cannot be blank")
   end
 
   test "size calculates the number of error messages" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
+    person.errors.add(:name, "cannot be blank")
     assert_equal 1, person.errors.size
   end
 
   test "to_a returns the list of errors with complete messages containing the attribute names" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    person.errors.add(:name, "can not be nil")
-    assert_equal ["name can not be blank", "name can not be nil"], person.errors.to_a
+    person.errors.add(:name, "cannot be blank")
+    person.errors.add(:name, "cannot be nil")
+    assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.to_a
   end
 
   test "to_hash returns the error messages hash" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    assert_equal({ name: ["can not be blank"] }, person.errors.to_hash)
+    person.errors.add(:name, "cannot be blank")
+    assert_equal({ name: ["cannot be blank"] }, person.errors.to_hash)
   end
 
   test "full_messages creates a list of error messages with the attribute name included" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    person.errors.add(:name, "can not be nil")
-    assert_equal ["name can not be blank", "name can not be nil"], person.errors.full_messages
+    person.errors.add(:name, "cannot be blank")
+    person.errors.add(:name, "cannot be nil")
+    assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages
   end
 
   test "full_messages_for contains all the error messages for the given attribute" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    person.errors.add(:name, "can not be nil")
-    assert_equal ["name can not be blank", "name can not be nil"], person.errors.full_messages_for(:name)
+    person.errors.add(:name, "cannot be blank")
+    person.errors.add(:name, "cannot be nil")
+    assert_equal ["name cannot be blank", "name cannot be nil"], person.errors.full_messages_for(:name)
   end
 
   test "full_messages_for does not contain error messages from other attributes" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
-    person.errors.add(:email, "can not be blank")
-    assert_equal ["name can not be blank"], person.errors.full_messages_for(:name)
+    person.errors.add(:name, "cannot be blank")
+    person.errors.add(:email, "cannot be blank")
+    assert_equal ["name cannot be blank"], person.errors.full_messages_for(:name)
   end
 
   test "full_messages_for returns an empty list in case there are no errors for the given attribute" do
     person = Person.new
-    person.errors.add(:name, "can not be blank")
+    person.errors.add(:name, "cannot be blank")
     assert_equal [], person.errors.full_messages_for(:email)
   end
 
@@ -230,22 +230,22 @@ class ErrorsTest < ActiveModel::TestCase
 
   test "full_message returns the given message with the attribute name included" do
     person = Person.new
-    assert_equal "name can not be blank", person.errors.full_message(:name, "can not be blank")
-    assert_equal "name_test can not be blank", person.errors.full_message(:name_test, "can not be blank")
+    assert_equal "name cannot be blank", person.errors.full_message(:name, "cannot be blank")
+    assert_equal "name_test cannot be blank", person.errors.full_message(:name_test, "cannot be blank")
   end
 
   test "as_json creates a json formatted representation of the errors hash" do
     person = Person.new
     person.validate!
 
-    assert_equal({ name: ["can not be nil"] }, person.errors.as_json)
+    assert_equal({ name: ["cannot be nil"] }, person.errors.as_json)
   end
 
   test "as_json with :full_messages option creates a json formatted representation of the errors containing complete messages" do
     person = Person.new
     person.validate!
 
-    assert_equal({ name: ["name can not be nil"] }, person.errors.as_json(full_messages: true))
+    assert_equal({ name: ["name cannot be nil"] }, person.errors.as_json(full_messages: true))
   end
 
   test "generate_message works without i18n_scope" do
diff --git a/activemodel/test/cases/helper.rb b/activemodel/test/cases/helper.rb
index 7a63674757..522a7cebb4 100644
--- a/activemodel/test/cases/helper.rb
+++ b/activemodel/test/cases/helper.rb
@@ -7,4 +7,7 @@ require 'active_support/core_ext/string/access'
 # Show backtraces for deprecated behavior for quicker cleanup.
 ActiveSupport::Deprecation.debug = true
 
+# Disable available locale checks to avoid warnings running the test suite.
+I18n.enforce_available_locales = false
+
 require 'active_support/testing/autorun'
diff --git a/activemodel/test/cases/model_test.rb b/activemodel/test/cases/model_test.rb
index 24e4ca91c6..ee0fa26546 100644
--- a/activemodel/test/cases/model_test.rb
+++ b/activemodel/test/cases/model_test.rb
@@ -3,7 +3,30 @@ require 'cases/helper'
 class ModelTest < ActiveModel::TestCase
   include ActiveModel::Lint::Tests
 
+  module DefaultValue
+    def self.included(klass)
+      klass.class_eval { attr_accessor :hello }
+    end
+
+    def initialize(*args)
+      @attr ||= 'default value'
+      super
+    end
+  end
+
   class BasicModel
+    include DefaultValue
+    include ActiveModel::Model
+    attr_accessor :attr
+  end
+
+  class BasicModelWithReversedMixins
+    include ActiveModel::Model
+    include DefaultValue
+    attr_accessor :attr
+  end
+
+  class SimpleModel
     include ActiveModel::Model
     attr_accessor :attr
   end
@@ -14,14 +37,20 @@ class ModelTest < ActiveModel::TestCase
 
   def test_initialize_with_params
     object = BasicModel.new(attr: "value")
-    assert_equal object.attr, "value"
+    assert_equal "value", object.attr
+  end
+
+  def test_initialize_with_params_and_mixins_reversed
+    object = BasicModelWithReversedMixins.new(attr: "value")
+    assert_equal "value", object.attr
   end
 
   def test_initialize_with_nil_or_empty_hash_params_does_not_explode
     assert_nothing_raised do
       BasicModel.new()
-      BasicModel.new nil
+      BasicModel.new(nil)
       BasicModel.new({})
+      SimpleModel.new(attr: 'value')
     end
   end
 
@@ -29,4 +58,18 @@ class ModelTest < ActiveModel::TestCase
     object = BasicModel.new(attr: "value")
     assert object.persisted? == false
   end
+
+  def test_mixin_inclusion_chain
+    object = BasicModel.new
+    assert_equal 'default value', object.attr
+  end
+
+  def test_mixin_initializer_when_args_exist
+    object = BasicModel.new(hello: 'world')
+    assert_equal 'world', object.hello
+  end
+
+  def test_mixin_initializer_when_args_dont_exist
+    assert_raises(NoMethodError) { SimpleModel.new(hello: 'world') }
+  end
 end
diff --git a/activemodel/test/cases/railtie_test.rb b/activemodel/test/cases/railtie_test.rb
index d44a3448df..96b3b07e50 100644
--- a/activemodel/test/cases/railtie_test.rb
+++ b/activemodel/test/cases/railtie_test.rb
@@ -7,8 +7,12 @@ class RailtieTest < ActiveModel::TestCase
   def setup
     require 'active_model/railtie'
 
+    # Set a fake logger to avoid creating the log directory automatically
+    fake_logger = Logger.new(nil)
+
     @app ||= Class.new(::Rails::Application) do
       config.eager_load = false
+      config.logger = fake_logger
     end
   end
 
diff --git a/activemodel/test/cases/secure_password_test.rb b/activemodel/test/cases/secure_password_test.rb
index 02cd3b8a93..0314803af6 100644
--- a/activemodel/test/cases/secure_password_test.rb
+++ b/activemodel/test/cases/secure_password_test.rb
@@ -2,7 +2,6 @@ require 'cases/helper'
 require 'models/user'
 require 'models/oauthed_user'
 require 'models/visitor'
-require 'models/administrator'
 
 class SecurePasswordTest < ActiveModel::TestCase
   setup do
@@ -82,6 +81,14 @@ class SecurePasswordTest < ActiveModel::TestCase
     assert_equal BCrypt::Engine::DEFAULT_COST, @user.password_digest.cost
   end
 
+  test "Password digest cost honors bcrypt cost attribute when min_cost is false" do
+    ActiveModel::SecurePassword.min_cost = false
+    BCrypt::Engine.cost = 5
+
+    @user.password = "secret"
+    assert_equal BCrypt::Engine.cost, @user.password_digest.cost
+  end
+
   test "Password digest cost can be set to bcrypt min cost to speed up tests" do
     ActiveModel::SecurePassword.min_cost = true
 
@@ -94,4 +101,18 @@ class SecurePasswordTest < ActiveModel::TestCase
     @user.password_confirmation = ""
     assert @user.valid?(:update), "user should be valid"
   end
+
+  test "password_confirmation validations will not be triggered if password_confirmation is not sent" do
+    @user.password = "password"
+    assert @user.valid?(:create)
+  end
+
+  test "will not save if confirmation is blank but password is not" do
+    @user.password = "password"
+    @user.password_confirmation = ""
+    assert_not @user.valid?(:create)
+
+    @user.password_confirmation = "password"
+    assert @user.valid?(:create)
+  end
 end
diff --git a/activemodel/test/cases/serializers/json_serialization_test.rb b/activemodel/test/cases/serializers/json_serialization_test.rb
index f0347081ee..bc185c737f 100644
--- a/activemodel/test/cases/serializers/json_serialization_test.rb
+++ b/activemodel/test/cases/serializers/json_serialization_test.rb
@@ -155,12 +155,6 @@ class JsonSerializationTest < ActiveModel::TestCase
     end
   end
 
-  test "as_json should keep the default order in the hash" do
-    json = @contact.as_json
-
-    assert_equal %w(name age created_at awesome preferences), json.keys
-  end
-
   test "from_json should work without a root (class attribute)" do
     json = @contact.to_json
     result = Contact.new.from_json(json)
@@ -204,7 +198,7 @@ class JsonSerializationTest < ActiveModel::TestCase
     assert_no_match %r{"preferences":}, json
   end
 
-  test "custom as_json options should be extendible" do
+  test "custom as_json options should be extensible" do
     def @contact.as_json(options = {}); super(options.merge(only: [:name])); end
     json = @contact.to_json
 
diff --git a/activemodel/test/cases/serializers/xml_serialization_test.rb b/activemodel/test/cases/serializers/xml_serialization_test.rb
index 901f42f29b..11ee17bb27 100644
--- a/activemodel/test/cases/serializers/xml_serialization_test.rb
+++ b/activemodel/test/cases/serializers/xml_serialization_test.rb
@@ -53,8 +53,7 @@ class XmlSerializationTest < ActiveModel::TestCase
     @contact.address.city = "Springfield"
     @contact.address.apt_number = 35
     @contact.friends = [Contact.new, Contact.new]
-    @related_contact = SerializableContact.new
-    @contact.contact = @related_contact
+    @contact.contact = SerializableContact.new
   end
 
   test "should serialize default root" do
@@ -130,7 +129,7 @@ class XmlSerializationTest < ActiveModel::TestCase
   end
 
   test "should serialize nil" do
-    assert_match %r{<pseudonyms nil=\"true\"/>}, @contact.to_xml(methods: :pseudonyms)
+    assert_match %r{<pseudonyms nil="true"/>}, @contact.to_xml(methods: :pseudonyms)
   end
 
   test "should serialize integer" do
@@ -138,23 +137,23 @@ class XmlSerializationTest < ActiveModel::TestCase
   end
 
   test "should serialize datetime" do
-    assert_match %r{<created-at type=\"dateTime\">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml
+    assert_match %r{<created-at type="dateTime">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml
   end
 
   test "should serialize boolean" do
-    assert_match %r{<awesome type=\"boolean\">false</awesome>}, @contact.to_xml
+    assert_match %r{<awesome type="boolean">false</awesome>}, @contact.to_xml
   end
 
   test "should serialize array" do
-    assert_match %r{<social type=\"array\">\s*<social>twitter</social>\s*<social>github</social>\s*</social>}, @contact.to_xml(methods: :social)
+    assert_match %r{<social type="array">\s*<social>twitter</social>\s*<social>github</social>\s*</social>}, @contact.to_xml(methods: :social)
   end
 
   test "should serialize hash" do
-    assert_match %r{<network>\s*<git type=\"symbol\">github</git>\s*</network>}, @contact.to_xml(methods: :network)
+    assert_match %r{<network>\s*<git type="symbol">github</git>\s*</network>}, @contact.to_xml(methods: :network)
   end
 
   test "should serialize yaml" do
-    assert_match %r{<preferences type=\"yaml\">--- !ruby/struct:Customer(\s*)\nname: John\n</preferences>}, @contact.to_xml
+    assert_match %r{<preferences type="yaml">--- !ruby/struct:Customer(\s*)\nname: John\n</preferences>}, @contact.to_xml
   end
 
   test "should call proc on object" do
diff --git a/activemodel/test/cases/validations/conditional_validation_test.rb b/activemodel/test/cases/validations/conditional_validation_test.rb
index 41a4c33727..5049d6dd61 100644
--- a/activemodel/test/cases/validations/conditional_validation_test.rb
+++ b/activemodel/test/cases/validations/conditional_validation_test.rb
@@ -23,7 +23,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: :condition_is_true)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_if_validation_using_method_false
@@ -31,7 +31,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: :condition_is_true_but_its_not)
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_unless_validation_using_method_false
@@ -57,7 +57,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", unless: "a = 1; a == 1")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_if_validation_using_string_false
@@ -65,7 +65,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
     Topic.validates_length_of(:title, maximum: 5, too_long: "hoo %{count}", if: "false")
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_unless_validation_using_string_false
@@ -93,7 +93,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
       unless: Proc.new { |r| r.content.size > 4 })
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_if_validation_using_block_false
@@ -102,7 +102,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
       if: Proc.new { |r| r.title != "uhohuhoh"})
     t = Topic.new("title" => "uhohuhoh", "content" => "whatever")
     assert t.valid?
-    assert t.errors[:title].empty?
+    assert_empty t.errors[:title]
   end
 
   def test_unless_validation_using_block_false
@@ -124,7 +124,7 @@ class ConditionalValidationTest < ActiveModel::TestCase
 
     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"
+    assert_empty t.errors[:author_name], "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"
diff --git a/activemodel/test/cases/validations/inclusion_validation_test.rb b/activemodel/test/cases/validations/inclusion_validation_test.rb
index ceec9dc256..8b90856869 100644
--- a/activemodel/test/cases/validations/inclusion_validation_test.rb
+++ b/activemodel/test/cases/validations/inclusion_validation_test.rb
@@ -1,5 +1,6 @@
 # encoding: utf-8
 require 'cases/helper'
+require 'active_support/all'
 
 require 'models/topic'
 require 'models/person'
@@ -14,11 +15,33 @@ class InclusionValidationTest < ActiveModel::TestCase
     Topic.validates_inclusion_of(:title, in: 'aaa'..'bbb')
     assert Topic.new("title" => "bbc", "content" => "abc").invalid?
     assert Topic.new("title" => "aa", "content" => "abc").invalid?
+    assert Topic.new("title" => "aaab", "content" => "abc").invalid?
     assert Topic.new("title" => "aaa", "content" => "abc").valid?
     assert Topic.new("title" => "abc", "content" => "abc").valid?
     assert Topic.new("title" => "bbb", "content" => "abc").valid?
   end
 
+  def test_validates_inclusion_of_time_range
+    Topic.validates_inclusion_of(:created_at, in: 1.year.ago..Time.now)
+    assert Topic.new(title: 'aaa', created_at: 2.years.ago).invalid?
+    assert Topic.new(title: 'aaa', created_at: 3.months.ago).valid?
+    assert Topic.new(title: 'aaa', created_at: 37.weeks.from_now).invalid?
+  end
+
+  def test_validates_inclusion_of_date_range
+    Topic.validates_inclusion_of(:created_at, in: 1.year.until(Date.today)..Date.today)
+    assert Topic.new(title: 'aaa', created_at: 2.years.until(Date.today)).invalid?
+    assert Topic.new(title: 'aaa', created_at: 3.months.until(Date.today)).valid?
+    assert Topic.new(title: 'aaa', created_at: 37.weeks.since(Date.today)).invalid?
+  end
+
+  def test_validates_inclusion_of_date_time_range
+    Topic.validates_inclusion_of(:created_at, in: 1.year.until(DateTime.current)..DateTime.current)
+    assert Topic.new(title: 'aaa', created_at: 2.years.until(DateTime.current)).invalid?
+    assert Topic.new(title: 'aaa', created_at: 3.months.until(DateTime.current)).valid?
+    assert Topic.new(title: 'aaa', created_at: 37.weeks.since(DateTime.current)).invalid?
+  end
+
   def test_validates_inclusion_of
     Topic.validates_inclusion_of(:title, in: %w( a b c d e f g ))
 
diff --git a/activemodel/test/cases/validations/with_validation_test.rb b/activemodel/test/cases/validations/with_validation_test.rb
index efe16d9aa9..93716f1433 100644
--- a/activemodel/test/cases/validations/with_validation_test.rb
+++ b/activemodel/test/cases/validations/with_validation_test.rb
@@ -100,35 +100,13 @@ class ValidatesWithTest < ActiveModel::TestCase
   test "passes all configuration options to the validator class" do
     topic = Topic.new
     validator = mock()
-    validator.expects(:new).with(foo: :bar, if: "1 == 1").returns(validator)
+    validator.expects(:new).with(foo: :bar, if: "1 == 1", class: Topic).returns(validator)
     validator.expects(:validate).with(topic)
 
     Topic.validates_with(validator, if: "1 == 1", foo: :bar)
     assert topic.valid?
   end
 
-  test "calls setup method of validator passing in self when validator has setup method" do
-    topic = Topic.new
-    validator = stub_everything
-    validator.stubs(:new).returns(validator)
-    validator.stubs(:validate)
-    validator.stubs(:respond_to?).with(:setup).returns(true)
-    validator.expects(:setup).with(Topic).once
-    Topic.validates_with(validator)
-    assert topic.valid?
-  end
-
-  test "doesn't call setup method of validator when validator has no setup method" do
-    topic = Topic.new
-    validator = stub_everything
-    validator.stubs(:new).returns(validator)
-    validator.stubs(:validate)
-    validator.stubs(:respond_to?).with(:setup).returns(false)
-    validator.expects(:setup).with(Topic).never
-    Topic.validates_with(validator)
-    assert topic.valid?
-  end
-
   test "validates_with with options" do
     Topic.validates_with(ValidatorThatValidatesOptions, field: :first_name)
     topic = Topic.new
diff --git a/activemodel/test/cases/validations_test.rb b/activemodel/test/cases/validations_test.rb
index 3e84297cc2..039b6b8872 100644
--- a/activemodel/test/cases/validations_test.rb
+++ b/activemodel/test/cases/validations_test.rb
@@ -373,4 +373,25 @@ class ValidationsTest < ActiveModel::TestCase
     assert topic.invalid?
     assert duped.valid?
   end
+
+   # validator test:
+  def test_setup_is_deprecated_but_still_receives_klass # TODO: remove me in 4.2.
+    validator_class = Class.new(ActiveModel::Validator) do
+      def setup(klass)
+        @old_klass = klass
+      end
+
+      def validate(*)
+        @old_klass == Topic or raise "#setup didn't work"
+      end
+    end
+
+    assert_deprecated do
+      Topic.validates_with validator_class
+    end
+
+    t = Topic.new
+    t.valid?
+  end
+
 end
diff --git a/activemodel/test/models/administrator.rb b/activemodel/test/models/administrator.rb
deleted file mode 100644
index 2f3aff290c..0000000000
--- a/activemodel/test/models/administrator.rb
+++ /dev/null
@@ -1,11 +0,0 @@
-class Administrator
-  extend ActiveModel::Callbacks
-  include ActiveModel::Validations
-  include ActiveModel::SecurePassword
-
-  define_model_callbacks :create
-
-  attr_accessor :name, :password_digest
-
-  has_secure_password
-end
diff --git a/activemodel/test/models/topic.rb b/activemodel/test/models/topic.rb
index c9af78f595..1411a093e9 100644
--- a/activemodel/test/models/topic.rb
+++ b/activemodel/test/models/topic.rb
@@ -6,7 +6,7 @@ class Topic
     super | [ :message ]
   end
 
-  attr_accessor :title, :author_name, :content, :approved
+  attr_accessor :title, :author_name, :content, :approved, :created_at
   attr_accessor :after_validation_performed
 
   after_validation :perform_after_validation