Merge branch 'master' of github.com:rails/rails

Conflicts:
	guides/source/security.md

43 files changed, 884 insertions, 278 deletions

diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 334eebc268..eaaa3df061 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,3 +1,27 @@
+*   Deprecate `:prefix` option of `number_to_human_size` with no replacement.
+
+    *Jean Boussier*
+
+*   Fix `TimeWithZone#eql?` to properly handle `TimeWithZone` created from `DateTime`:
+        twz = DateTime.now.in_time_zone
+        twz.eql?(twz.dup) => true
+
+    Fixes #14178.
+
+    *Roque Pinel*
+
+*   ActiveSupport::HashWithIndifferentAccess `select` and `reject` will now return
+    enumerator if called without block.
+
+    Fixes #20095
+
+    *Bernard Potocki*
+
+*   Removed `ActiveSupport::Concurrency::Latch`, superseded by `Concurrent::CountDownLatch`
+    from the concurrent-ruby gem.
+
+    *Jerry D'Antonio*
+
 *   Fix not calling `#default` on `HashWithIndifferentAccess#to_hash` when only
     `default_proc` is set, which could raise.
 
diff --git a/activesupport/activesupport.gemspec b/activesupport/activesupport.gemspec
index 12c6a4d449..6d2ae9be76 100644
--- a/activesupport/activesupport.gemspec
+++ b/activesupport/activesupport.gemspec
@@ -25,4 +25,6 @@ Gem::Specification.new do |s|
   s.add_dependency 'tzinfo',     '~> 1.1'
   s.add_dependency 'minitest',   '~> 5.1'
   s.add_dependency 'thread_safe','~> 0.3', '>= 0.3.4'
+  s.add_dependency 'concurrent-ruby', '~> 0.9.0'
+  s.add_dependency 'method_source'
 end
diff --git a/activesupport/lib/active_support/cache.rb b/activesupport/lib/active_support/cache.rb
index 837974bc85..8253a76383 100644
--- a/activesupport/lib/active_support/cache.rb
+++ b/activesupport/lib/active_support/cache.rb
@@ -26,7 +26,7 @@ module ActiveSupport
     end
 
     class << self
-      # Creates a new CacheStore object according to the given options.
+      # Creates a new Store object according to the given options.
       #
       # If no arguments are passed to this method, then a new
       # ActiveSupport::Cache::MemoryStore object will be returned.
diff --git a/activesupport/lib/active_support/callbacks.rb b/activesupport/lib/active_support/callbacks.rb
index e8ab3a7db5..fefba5b0fd 100644
--- a/activesupport/lib/active_support/callbacks.rb
+++ b/activesupport/lib/active_support/callbacks.rb
@@ -80,8 +80,12 @@ module ActiveSupport
     #     save
     #   end
     def run_callbacks(kind, &block)
-      callbacks = send("_#{kind}_callbacks")
+      send "_run_#{kind}_callbacks", &block
+    end
+
+    private
 
+    def __run_callbacks__(callbacks, &block)
       if callbacks.empty?
         yield if block_given?
       else
@@ -91,8 +95,6 @@ module ActiveSupport
       end
     end
 
-    private
-
     # A hook invoked every time a before callback is halted.
     # This can be overridden in AS::Callback implementors in order
     # to provide better debugging/logging.
@@ -739,10 +741,10 @@ module ActiveSupport
       #   callback chain, preventing following before and around callbacks from
       #   being called and the event from being triggered.
       #   This should be a lambda to be executed.
-      #   The current object and the return result of the callback will be called
-      #   with the lambda.
+      #   The current object and the result lambda of the callback will be provided
+      #   to the terminator lambda.
       #
-      #     define_callbacks :validate, terminator: ->(target, result) { result == false }
+      #     define_callbacks :validate, terminator: ->(target, result_lambda) { result_lambda.call == false }
       #
       #   In this example, if any before validate callbacks returns +false+,
       #   any successive before and around callback is not executed.
@@ -806,6 +808,12 @@ module ActiveSupport
         names.each do |name|
           class_attribute "_#{name}_callbacks"
           set_callbacks name, CallbackChain.new(name, options)
+
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def _run_#{name}_callbacks(&block)
+              __run_callbacks__(_#{name}_callbacks, &block)
+            end
+          RUBY
         end
       end
 
diff --git a/activesupport/lib/active_support/concurrency/latch.rb b/activesupport/lib/active_support/concurrency/latch.rb
index 1507de433e..7b8df0df04 100644
--- a/activesupport/lib/active_support/concurrency/latch.rb
+++ b/activesupport/lib/active_support/concurrency/latch.rb
@@ -1,26 +1,18 @@
-require 'thread'
-require 'monitor'
+require 'concurrent/atomics'
 
 module ActiveSupport
   module Concurrency
-    class Latch
-      def initialize(count = 1)
-        @count = count
-        @lock = Monitor.new
-        @cv = @lock.new_cond
-      end
+    class Latch < Concurrent::CountDownLatch
 
-      def release
-        @lock.synchronize do
-          @count -= 1 if @count > 0
-          @cv.broadcast if @count.zero?
-        end
+      def initialize(count = 1)
+        ActiveSupport::Deprecation.warn("ActiveSupport::Concurrency::Latch is deprecated. Please use Concurrent::CountDownLatch instead.")
+        super(count)
       end
+      
+      alias_method :release, :count_down
 
       def await
-        @lock.synchronize do
-          @cv.wait_while { @count > 0 }
-        end
+        wait(nil)
       end
     end
   end
diff --git a/activesupport/lib/active_support/concurrency/share_lock.rb b/activesupport/lib/active_support/concurrency/share_lock.rb
index f1c6230084..ca48164c54 100644
--- a/activesupport/lib/active_support/concurrency/share_lock.rb
+++ b/activesupport/lib/active_support/concurrency/share_lock.rb
@@ -9,7 +9,7 @@ module ActiveSupport
     #--
     # Note that a pending Exclusive lock attempt does not block incoming
     # Share requests (i.e., we are "read-preferring"). That seems
-    # consistent with the behavior of +loose_upgrades+, but may be the
+    # consistent with the behavior of "loose" upgrades, but may be the
     # wrong choice otherwise: it nominally reduces the possibility of
     # deadlock by risking starvation instead.
     class ShareLock
@@ -20,47 +20,48 @@ module ActiveSupport
       # to upgrade share locks to exclusive.
 
 
-      # If +loose_upgrades+ is false (the default), then a thread that
-      # is waiting on an Exclusive lock will continue to hold any Share
-      # lock that it has already established. This is safer, but can
-      # lead to deadlock.
-      #
-      # If +loose_upgrades+ is true, a thread waiting on an Exclusive
-      # lock will temporarily relinquish its Share lock. Being less
-      # strict, this behavior prevents some classes of deadlocks. For
-      # many resources, loose upgrades are sufficient: if a thread is
-      # awaiting a lock, it is not running any other code.
-      attr_reader :loose_upgrades
-
-      def initialize(loose_upgrades = false)
-        @loose_upgrades = loose_upgrades
-
+      def initialize
         super()
 
         @cv = new_cond
 
         @sharing = Hash.new(0)
+        @waiting = {}
         @exclusive_thread = nil
         @exclusive_depth = 0
       end
 
-      # Returns false if +no_wait+ is specified and the lock is not
+      # Returns false if +no_wait+ is set and the lock is not
       # immediately available. Otherwise, returns true after the lock
       # has been acquired.
-      def start_exclusive(no_wait=false)
+      #
+      # +purpose+ and +compatible+ work together; while this thread is
+      # waiting for the exclusive lock, it will yield its share (if any)
+      # to any other attempt whose +purpose+ appears in this attempt's
+      # +compatible+ list. This allows a "loose" upgrade, which, being
+      # less strict, prevents some classes of deadlocks.
+      #
+      # For many resources, loose upgrades are sufficient: if a thread
+      # is awaiting a lock, it is not running any other code. With
+      # +purpose+ matching, it is possible to yield only to other
+      # threads whose activity will not interfere.
+      def start_exclusive(purpose: nil, compatible: [], no_wait: false)
         synchronize do
           unless @exclusive_thread == Thread.current
-            return false if no_wait && busy?
+            if busy?(purpose)
+              return false if no_wait
 
-            loose_shares = nil
-            if @loose_upgrades
               loose_shares = @sharing.delete(Thread.current)
+              @waiting[Thread.current] = compatible if loose_shares
+
+              begin
+                @cv.wait_while { busy?(purpose) }
+              ensure
+                @waiting.delete Thread.current
+                @sharing[Thread.current] = loose_shares if loose_shares
+              end
             end
-
-            @cv.wait_while { busy? } if busy?
-
             @exclusive_thread = Thread.current
-            @sharing[Thread.current] = loose_shares if loose_shares
           end
           @exclusive_depth += 1
 
@@ -106,8 +107,10 @@ module ActiveSupport
       # +no_wait+ is set and the lock is not immediately available,
       # returns +nil+ without yielding. Otherwise, returns the result of
       # the block.
-      def exclusive(no_wait=false)
-        if start_exclusive(no_wait)
+      #
+      # See +start_exclusive+ for other options.
+      def exclusive(purpose: nil, compatible: [], no_wait: false)
+        if start_exclusive(purpose: purpose, compatible: compatible, no_wait: no_wait)
           begin
             yield
           ensure
@@ -129,8 +132,9 @@ module ActiveSupport
       private
 
       # Must be called within synchronize
-      def busy?
+      def busy?(purpose)
         (@exclusive_thread && @exclusive_thread != Thread.current) ||
+          @waiting.any? { |k, v| k != Thread.current && !v.include?(purpose) } ||
           @sharing.size > (@sharing[Thread.current] > 0 ? 1 : 0)
       end
     end
diff --git a/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb b/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
index 01153606c9..40811dafc0 100644
--- a/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/date_and_time/calculations.rb
@@ -92,15 +92,28 @@ module DateAndTime
     end
 
     # Returns a new date/time at the start of the month.
-    # DateTime objects will have a time set to 0:00.
+    #
+    #   today = Date.today # => Thu, 18 Jun 2015
+    #   today.beginning_of_month # => Mon, 01 Jun 2015
+    #
+    # +DateTime+ objects will have a time set to 0:00.
+    #
+    #   now = DateTime.current # => Thu, 18 Jun 2015 15:23:13 +0000
+    #   now.beginning_of_month # => Mon, 01 Jun 2015 00:00:00 +0000
     def beginning_of_month
       first_hour(change(:day => 1))
     end
     alias :at_beginning_of_month :beginning_of_month
 
     # Returns a new date/time at the start of the quarter.
-    # Example: 1st January, 1st July, 1st October.
-    # DateTime objects will have a time set to 0:00.
+    #
+    #   today = Date.today # => Fri, 10 Jul 2015
+    #   today.beginning_of_quarter # => Wed, 01 Jul 2015
+    #
+    # +DateTime+ objects will have a time set to 0:00.
+    #
+    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
+    #   now.beginning_of_quarter # => Wed, 01 Jul 2015 00:00:00 +0000
     def beginning_of_quarter
       first_quarter_month = [10, 7, 4, 1].detect { |m| m <= month }
       beginning_of_month.change(:month => first_quarter_month)
@@ -108,8 +121,14 @@ module DateAndTime
     alias :at_beginning_of_quarter :beginning_of_quarter
 
     # Returns a new date/time at the end of the quarter.
-    # Example: 31st March, 30th June, 30th September.
-    # DateTime objects will have a time set to 23:59:59.
+    #
+    #   today = Date.today # => Fri, 10 Jul 2015
+    #   today.end_of_quarter # => Wed, 30 Sep 2015
+    #
+    # +DateTime+ objects will have a time set to 23:59:59.
+    #
+    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
+    #   now.end_of_quarter # => Wed, 30 Sep 2015 23:59:59 +0000
     def end_of_quarter
       last_quarter_month = [3, 6, 9, 12].detect { |m| m >= month }
       beginning_of_month.change(:month => last_quarter_month).end_of_month
@@ -117,8 +136,14 @@ module DateAndTime
     alias :at_end_of_quarter :end_of_quarter
 
     # Return a new date/time at the beginning of the year.
-    # Example: 1st January.
-    # DateTime objects will have a time set to 0:00.
+    #
+    #   today = Date.today # => Fri, 10 Jul 2015
+    #   today.beginning_of_year # => Thu, 01 Jan 2015
+    #
+    # +DateTime+ objects will have a time set to 0:00.
+    #
+    #   now = DateTime.current # => Fri, 10 Jul 2015 18:41:29 +0000
+    #   now.beginning_of_year # => Thu, 01 Jan 2015 00:00:00 +0000
     def beginning_of_year
       change(:month => 1).beginning_of_month
     end
@@ -138,8 +163,8 @@ module DateAndTime
     #
     # +DateTime+ objects have their time set to 0:00 unless +same_time+ is true.
     #
-    #   now = Time.current # => Thu, 07 May 2015 13:31:16 UTC +00:00
-    #   now.next_week      # => Mon, 11 May 2015 00:00:00 UTC +00:00
+    #   now = DateTime.current # => Thu, 07 May 2015 13:31:16 +0000
+    #   now.next_week      # => Mon, 11 May 2015 00:00:00 +0000
     def next_week(given_day_in_next_week = Date.beginning_of_week, same_time: false)
       result = first_hour(weeks_since(1).beginning_of_week.days_since(days_span(given_day_in_next_week)))
       same_time ? copy_time_to(result) : result
diff --git a/activesupport/lib/active_support/core_ext/file/atomic.rb b/activesupport/lib/active_support/core_ext/file/atomic.rb
index fad6fa8d9d..ab635f6db8 100644
--- a/activesupport/lib/active_support/core_ext/file/atomic.rb
+++ b/activesupport/lib/active_support/core_ext/file/atomic.rb
@@ -8,43 +8,45 @@ class File
   #     file.write('hello')
   #   end
   #
-  # If your temp directory is not on the same filesystem as the file you're
-  # trying to write, you can provide a different temporary directory.
+  # This method needs to create a temporary file. By default it will create it
+  # in the same directory as the destination file. If you don't like this
+  # behaviour you can provide a different directory but it must be on the
+  # same physical filesystem as the the file you're trying to write.
   #
   #   File.atomic_write('/data/something.important', '/data/tmp') do |file|
   #     file.write('hello')
   #   end
-  def self.atomic_write(file_name, temp_dir = Dir.tmpdir)
+  def self.atomic_write(file_name, temp_dir = dirname(file_name))
     require 'tempfile' unless defined?(Tempfile)
-    require 'fileutils' unless defined?(FileUtils)
 
-    temp_file = Tempfile.new(basename(file_name), temp_dir)
-    temp_file.binmode
-    return_val = yield temp_file
-    temp_file.close
+    Tempfile.open(".#{basename(file_name)}", temp_dir) do |temp_file|
+      temp_file.binmode
+      return_val = yield temp_file
+      temp_file.close
 
-    if File.exist?(file_name)
-      # Get original file permissions
-      old_stat = stat(file_name)
-    else
-      # If not possible, probe which are the default permissions in the
-      # destination directory.
-      old_stat = probe_stat_in(dirname(file_name))
-    end
-
-    # Overwrite original file with temp file
-    FileUtils.mv(temp_file.path, file_name)
+      old_stat = if exist?(file_name)
+        # Get original file permissions
+        stat(file_name)
+      elsif temp_dir != dirname(file_name)
+        # If not possible, probe which are the default permissions in the
+        # destination directory.
+        probe_stat_in(dirname(file_name))
+      end
 
-    # Set correct permissions on new file
-    begin
-      chown(old_stat.uid, old_stat.gid, file_name)
-      # This operation will affect filesystem ACL's
-      chmod(old_stat.mode, file_name)
+      if old_stat
+        # Set correct permissions on new file
+        begin
+          chown(old_stat.uid, old_stat.gid, temp_file.path)
+          # This operation will affect filesystem ACL's
+          chmod(old_stat.mode, temp_file.path)
+        rescue Errno::EPERM, Errno::EACCES
+          # Changing file ownership failed, moving on.
+        end
+      end
 
-      # Make sure we return the result of the yielded block
+      # Overwrite original file with temp file
+      rename(temp_file.path, file_name)
       return_val
-    rescue Errno::EPERM, Errno::EACCES
-      # Changing file ownership failed, moving on.
     end
   end
 
diff --git a/activesupport/lib/active_support/core_ext/hash/except.rb b/activesupport/lib/active_support/core_ext/hash/except.rb
index 6e397abf51..2f6d38c1f6 100644
--- a/activesupport/lib/active_support/core_ext/hash/except.rb
+++ b/activesupport/lib/active_support/core_ext/hash/except.rb
@@ -1,8 +1,9 @@
 class Hash
-  # Returns a hash that includes everything but the given keys.
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.except(:c) # => { a: true, b: false}
-  #   hash # => { a: true, b: false, c: nil}
+  # Returns a hash that includes everything except given keys.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except(:c)     # => { a: true, b: false }
+  #   hash.except(:a, :b) # => { c: nil }
+  #   hash                # => { a: true, b: false, c: nil }
   #
   # This is useful for limiting a set of parameters to everything but a few known toggles:
   #   @person.update(params[:person].except(:admin))
@@ -10,10 +11,10 @@ class Hash
     dup.except!(*keys)
   end
 
-  # Replaces the hash without the given keys.
-  #   hash = { a: true, b: false, c: nil}
-  #   hash.except!(:c) # => { a: true, b: false}
-  #   hash # => { a: true, b: false }
+  # Removes the given keys from hash and returns it.
+  #   hash = { a: true, b: false, c: nil }
+  #   hash.except!(:c) # => { a: true, b: false }
+  #   hash             # => { a: true, b: false }
   def except!(*keys)
     keys.each { |key| delete(key) }
     self
diff --git a/activesupport/lib/active_support/core_ext/load_error.rb b/activesupport/lib/active_support/core_ext/load_error.rb
index d9fb392752..60732eb41a 100644
--- a/activesupport/lib/active_support/core_ext/load_error.rb
+++ b/activesupport/lib/active_support/core_ext/load_error.rb
@@ -23,7 +23,7 @@ class LoadError
   # Returns true if the given path name (except perhaps for the ".rb"
   # extension) is the missing file which caused the exception to be raised.
   def is_missing?(location)
-    location.sub(/\.rb$/, '') == path.sub(/\.rb$/, '')
+    location.sub(/\.rb$/, ''.freeze) == path.sub(/\.rb$/, ''.freeze)
   end
 end
 
diff --git a/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb b/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
index d4e6b5a1ac..a77da573fe 100644
--- a/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
+++ b/activesupport/lib/active_support/core_ext/module/attribute_accessors.rb
@@ -206,7 +206,7 @@ class Module
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
   def mattr_accessor(*syms, &blk)
     mattr_reader(*syms, &blk)
-    mattr_writer(*syms, &blk)
+    mattr_writer(*syms)
   end
   alias :cattr_accessor :mattr_accessor
 end
diff --git a/activesupport/lib/active_support/core_ext/module/delegation.rb b/activesupport/lib/active_support/core_ext/module/delegation.rb
index 9b7a429db9..9dc0dee1bd 100644
--- a/activesupport/lib/active_support/core_ext/module/delegation.rb
+++ b/activesupport/lib/active_support/core_ext/module/delegation.rb
@@ -167,7 +167,7 @@ class Module
         ''
       end
 
-    file, line = caller(1, 1).first.split(':', 2)
+    file, line = caller(1, 1).first.split(':'.freeze, 2)
     line = line.to_i
 
     to = to.to_s
diff --git a/activesupport/lib/active_support/core_ext/object/duplicable.rb b/activesupport/lib/active_support/core_ext/object/duplicable.rb
index 6fc0cb53f0..befa5aee21 100644
--- a/activesupport/lib/active_support/core_ext/object/duplicable.rb
+++ b/activesupport/lib/active_support/core_ext/object/duplicable.rb
@@ -81,7 +81,7 @@ class BigDecimal
   # BigDecimals are duplicable:
   #
   # BigDecimal.new("1.2").duplicable? # => true
-  # BigDecimal.new("1.2").dup # => #<BigDecimal:7f9d698eee10,'0.12E1',18(18)>
+  # BigDecimal.new("1.2").dup         # => #<BigDecimal:...,'0.12E1',18(18)>
   def duplicable?
     true
   end
diff --git a/activesupport/lib/active_support/core_ext/object/try.rb b/activesupport/lib/active_support/core_ext/object/try.rb
index 69be6c4abc..c67eb25b68 100644
--- a/activesupport/lib/active_support/core_ext/object/try.rb
+++ b/activesupport/lib/active_support/core_ext/object/try.rb
@@ -8,7 +8,7 @@ module ActiveSupport
 
     def try!(*a, &b)
       if a.empty? && block_given?
-        if b.arity.zero?
+        if b.arity == 0
           instance_eval(&b)
         else
           yield self
diff --git a/activesupport/lib/active_support/core_ext/string/inflections.rb b/activesupport/lib/active_support/core_ext/string/inflections.rb
index 97f9720b2b..b2e713077c 100644
--- a/activesupport/lib/active_support/core_ext/string/inflections.rb
+++ b/activesupport/lib/active_support/core_ext/string/inflections.rb
@@ -164,7 +164,7 @@ class String
   #
   #   <%= link_to(@person.name, person_path) %>
   #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
-  def parameterize(sep = '-')
+  def parameterize(sep = '-'.freeze)
     ActiveSupport::Inflector.parameterize(self, sep)
   end
 
@@ -172,7 +172,7 @@ class String
   # uses the +pluralize+ method on the last word in the string.
   #
   #   'RawScaledScorer'.tableize # => "raw_scaled_scorers"
-  #   'egg_and_ham'.tableize     # => "egg_and_hams"
+  #   'ham_and_egg'.tableize     # => "ham_and_eggs"
   #   'fancyCategory'.tableize   # => "fancy_categories"
   def tableize
     ActiveSupport::Inflector.tableize(self)
@@ -182,7 +182,7 @@ class String
   # Note that this returns a string and not a class. (To convert to an actual class
   # follow +classify+ with +constantize+.)
   #
-  #   'egg_and_hams'.classify # => "EggAndHam"
+  #   'ham_and_eggs'.classify # => "HamAndEgg"
   #   'posts'.classify        # => "Post"
   def classify
     ActiveSupport::Inflector.classify(self)
diff --git a/activesupport/lib/active_support/core_ext/time/calculations.rb b/activesupport/lib/active_support/core_ext/time/calculations.rb
index c554501893..96156deebb 100644
--- a/activesupport/lib/active_support/core_ext/time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/time/calculations.rb
@@ -108,6 +108,12 @@ class Time
   # takes a hash with any of these keys: <tt>:years</tt>, <tt>:months</tt>,
   # <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>, <tt>:minutes</tt>,
   # <tt>:seconds</tt>.
+  #
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(seconds: 1) # => 2015-08-01 14:35:01 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(minutes: 1) # => 2015-08-01 14:36:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(hours: 1)   # => 2015-08-01 15:35:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(days: 1)    # => 2015-08-02 14:35:00 -0700
+  #   Time.new(2015, 8, 1, 14, 35, 0).advance(weeks: 1)   # => 2015-08-08 14:35:00 -0700
   def advance(options)
     unless options[:weeks].nil?
       options[:weeks], partial_weeks = options[:weeks].divmod(1)
diff --git a/activesupport/lib/active_support/core_ext/time/zones.rb b/activesupport/lib/active_support/core_ext/time/zones.rb
index d683e7c777..133d3938eb 100644
--- a/activesupport/lib/active_support/core_ext/time/zones.rb
+++ b/activesupport/lib/active_support/core_ext/time/zones.rb
@@ -65,7 +65,8 @@ class Time
       if !time_zone || time_zone.is_a?(ActiveSupport::TimeZone)
         time_zone
       else
-        # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
+        # Look up the timezone based on the identifier (unless we've been
+        # passed a TZInfo::Timezone)
         unless time_zone.respond_to?(:period_for_local)
           time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
         end
diff --git a/activesupport/lib/active_support/dependencies.rb b/activesupport/lib/active_support/dependencies.rb
index 770c845435..f76ef04f49 100644
--- a/activesupport/lib/active_support/dependencies.rb
+++ b/activesupport/lib/active_support/dependencies.rb
@@ -37,6 +37,13 @@ module ActiveSupport #:nodoc:
       Dependencies.interlock.loading { yield }
     end
 
+    # Execute the supplied block while holding an exclusive lock,
+    # preventing any other thread from being inside a #run_interlock
+    # block at the same time
+    def self.unload_interlock
+      Dependencies.interlock.unloading { yield }
+    end
+
     # :nodoc:
 
     # Should we turn on Ruby warnings on the first load of dependent files?
@@ -149,7 +156,7 @@ module ActiveSupport #:nodoc:
 
           # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::")
+            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
           end
         end
         constants
@@ -255,12 +262,10 @@ module ActiveSupport #:nodoc:
       end
 
       def load_dependency(file)
-        Dependencies.load_interlock do
-          if Dependencies.load? && ActiveSupport::Dependencies.constant_watch_stack.watching?
-            Dependencies.new_constants_in(Object) { yield }
-          else
-            yield
-          end
+        if Dependencies.load? && ActiveSupport::Dependencies.constant_watch_stack.watching?
+          Dependencies.new_constants_in(Object) { yield }
+        else
+          yield
         end
       rescue Exception => exception  # errors from loading file
         exception.blame_file! file if exception.respond_to? :blame_file!
@@ -348,7 +353,7 @@ module ActiveSupport #:nodoc:
 
     def clear
       log_call
-      Dependencies.load_interlock do
+      Dependencies.unload_interlock do
         loaded.clear
         loading.clear
         remove_unloadable_constants!
@@ -431,7 +436,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb")
+      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -516,7 +521,7 @@ module ActiveSupport #:nodoc:
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, '')
+        expanded.sub!(/\.rb\z/, ''.freeze)
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
diff --git a/activesupport/lib/active_support/dependencies/interlock.rb b/activesupport/lib/active_support/dependencies/interlock.rb
index 148212c951..fbeb904684 100644
--- a/activesupport/lib/active_support/dependencies/interlock.rb
+++ b/activesupport/lib/active_support/dependencies/interlock.rb
@@ -4,21 +4,27 @@ module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     class Interlock
       def initialize # :nodoc:
-        @lock = ActiveSupport::Concurrency::ShareLock.new(true)
+        @lock = ActiveSupport::Concurrency::ShareLock.new
       end
 
       def loading
-        @lock.exclusive do
+        @lock.exclusive(purpose: :load, compatible: [:load]) do
           yield
         end
       end
 
-      # Attempt to obtain a "loading" (exclusive) lock. If possible,
+      def unloading
+        @lock.exclusive(purpose: :unload, compatible: [:load, :unload]) do
+          yield
+        end
+      end
+
+      # Attempt to obtain an "unloading" (exclusive) lock. If possible,
       # execute the supplied block while holding the lock. If there is
       # concurrent activity, return immediately (without executing the
       # block) instead of waiting.
-      def attempt_loading
-        @lock.exclusive(true) do
+      def attempt_unloading
+        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], no_wait: true) do
           yield
         end
       end
diff --git a/activesupport/lib/active_support/hash_with_indifferent_access.rb b/activesupport/lib/active_support/hash_with_indifferent_access.rb
index 63690a1342..0371f760b0 100644
--- a/activesupport/lib/active_support/hash_with_indifferent_access.rb
+++ b/activesupport/lib/active_support/hash_with_indifferent_access.rb
@@ -92,7 +92,7 @@ module ActiveSupport
     #   hash = ActiveSupport::HashWithIndifferentAccess.new
     #   hash[:key] = 'value'
     #
-    # This value can be later fetched using either +:key+ or +'key'+.
+    # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
     def []=(key, value)
       regular_writer(convert_key(key), convert_value(value, for: :assignment))
     end
@@ -238,10 +238,12 @@ module ActiveSupport
     def to_options!; self end
 
     def select(*args, &block)
+      return to_enum(:select) unless block_given?
       dup.tap { |hash| hash.select!(*args, &block) }
     end
 
     def reject(*args, &block)
+      return to_enum(:reject) unless block_given?
       dup.tap { |hash| hash.reject!(*args, &block) }
     end
 
diff --git a/activesupport/lib/active_support/i18n_railtie.rb b/activesupport/lib/active_support/i18n_railtie.rb
index 95f3f6255a..6775eec34b 100644
--- a/activesupport/lib/active_support/i18n_railtie.rb
+++ b/activesupport/lib/active_support/i18n_railtie.rb
@@ -37,10 +37,12 @@ module I18n
       enforce_available_locales = I18n.enforce_available_locales if enforce_available_locales.nil?
       I18n.enforce_available_locales = false
 
+      reloadable_paths = []
       app.config.i18n.each do |setting, value|
         case setting
         when :railties_load_path
-          app.config.i18n.load_path.unshift(*value)
+          reloadable_paths = value
+          app.config.i18n.load_path.unshift(*value.map(&:existent).flatten)
         when :load_path
           I18n.load_path += value
         else
@@ -53,7 +55,14 @@ module I18n
       # Restore available locales check so it will take place from now on.
       I18n.enforce_available_locales = enforce_available_locales
 
-      reloader = ActiveSupport::FileUpdateChecker.new(I18n.load_path.dup){ I18n.reload! }
+      directories = watched_dirs_with_extensions(reloadable_paths)
+      reloader = ActiveSupport::FileUpdateChecker.new(I18n.load_path.dup, directories) do
+        I18n.load_path.keep_if { |p| File.exist?(p) }
+        I18n.load_path |= reloadable_paths.map(&:existent).flatten
+
+        I18n.reload!
+      end
+
       app.reloaders << reloader
       ActionDispatch::Reloader.to_prepare do
         reloader.execute_if_updated
@@ -96,5 +105,11 @@ module I18n
         raise "Unexpected fallback type #{fallbacks.inspect}"
       end
     end
+
+    def self.watched_dirs_with_extensions(paths)
+      paths.each_with_object({}) do |path, result|
+        result[path.absolute_current] = path.extensions
+      end
+    end
   end
 end
diff --git a/activesupport/lib/active_support/inflector/inflections.rb b/activesupport/lib/active_support/inflector/inflections.rb
index 486838bd15..42560f3515 100644
--- a/activesupport/lib/active_support/inflector/inflections.rb
+++ b/activesupport/lib/active_support/inflector/inflections.rb
@@ -27,6 +27,37 @@ module ActiveSupport
     class Inflections
       @__instance__ = ThreadSafe::Cache.new
 
+      class Uncountables < Array
+        def initialize
+          @regex_array = []
+          super
+        end
+
+        def delete(entry)
+          super entry
+          @regex_array.delete(to_regex(entry))
+        end
+
+        def <<(*word)
+          add(word)
+        end
+
+        def add(words)
+          self.concat(words.flatten.map(&:downcase))
+          @regex_array += self.map {|word|  to_regex(word) }
+          self
+        end
+
+        def uncountable?(str)
+          @regex_array.any? { |regex| regex === str }
+        end
+
+        private
+          def to_regex(string)
+            /\b#{::Regexp.escape(string)}\Z/i
+          end
+      end
+
       def self.instance(locale = :en)
         @__instance__[locale] ||= new
       end
@@ -34,7 +65,7 @@ module ActiveSupport
       attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
 
       def initialize
-        @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], [], [], {}, /(?=a)b/
+        @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], Uncountables.new, [], {}, /(?=a)b/
       end
 
       # Private, for the test suite.
@@ -160,7 +191,7 @@ module ActiveSupport
       #   uncountable 'money', 'information'
       #   uncountable %w( money information rice )
       def uncountable(*words)
-        @uncountables += words.flatten.map(&:downcase)
+        @uncountables.add(words)
       end
 
       # Specifies a humanized form of a string by a regular expression rule or
@@ -185,7 +216,7 @@ module ActiveSupport
       def clear(scope = :all)
         case scope
           when :all
-            @plurals, @singulars, @uncountables, @humans = [], [], [], []
+            @plurals, @singulars, @uncountables, @humans = [], [], Uncountables.new, []
           else
             instance_variable_set "@#{scope}", []
         end
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index be369d21c6..ab5372ac43 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -91,10 +91,10 @@ module ActiveSupport
     def underscore(camel_cased_word)
       return camel_cased_word unless camel_cased_word =~ /[A-Z-]|::/
       word = camel_cased_word.to_s.gsub('::'.freeze, '/'.freeze)
-      word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'}#{$2.downcase}" }
-      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
-      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
-      word.tr!("-", "_")
+      word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+      word.gsub!(/([A-Z\d]+)([A-Z][a-z])/, '\1_\2'.freeze)
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2'.freeze)
+      word.tr!("-".freeze, "_".freeze)
       word.downcase!
       word
     end
@@ -127,9 +127,9 @@ module ActiveSupport
 
       inflections.humans.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
 
-      result.sub!(/\A_+/, '')
-      result.sub!(/_id\z/, '')
-      result.tr!('_', ' ')
+      result.sub!(/\A_+/, ''.freeze)
+      result.sub!(/_id\z/, ''.freeze)
+      result.tr!('_'.freeze, ' '.freeze)
 
       result.gsub!(/([a-z\d]*)/i) do |match|
         "#{inflections.acronyms[match] || match.downcase}"
@@ -160,7 +160,7 @@ module ActiveSupport
     # This method uses the #pluralize method on the last word in the string.
     #
     #   tableize('RawScaledScorer') # => "raw_scaled_scorers"
-    #   tableize('egg_and_ham')     # => "egg_and_hams"
+    #   tableize('ham_and_egg')     # => "ham_and_eggs"
     #   tableize('fancyCategory')   # => "fancy_categories"
     def tableize(class_name)
       pluralize(underscore(class_name))
@@ -170,7 +170,7 @@ module ActiveSupport
     # names to models. Note that this returns a string and not a Class (To
     # convert to an actual class follow +classify+ with #constantize).
     #
-    #   classify('egg_and_hams') # => "EggAndHam"
+    #   classify('ham_and_eggs') # => "HamAndEgg"
     #   classify('posts')        # => "Post"
     #
     # Singular names are not handled correctly:
@@ -178,14 +178,14 @@ module ActiveSupport
     #   classify('calculus')     # => "Calculu"
     def classify(table_name)
       # strip out any leading schema name
-      camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+      camelize(singularize(table_name.to_s.sub(/.*\./, ''.freeze)))
     end
 
     # Replaces underscores with dashes in the string.
     #
     #   dasherize('puni_puni') # => "puni-puni"
     def dasherize(underscored_word)
-      underscored_word.tr('_', '-')
+      underscored_word.tr('_'.freeze, '-'.freeze)
     end
 
     # Removes the module part from the expression in the string.
@@ -248,7 +248,7 @@ module ActiveSupport
     # NameError is raised when the name is not in CamelCase or the constant is
     # unknown.
     def constantize(camel_cased_word)
-      names = camel_cased_word.split('::')
+      names = camel_cased_word.split('::'.freeze)
 
       # Trigger a built-in NameError exception including the ill-formed constant in the message.
       Object.const_get(camel_cased_word) if names.empty?
@@ -354,7 +354,7 @@ module ActiveSupport
     #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
     #   const_regexp("::")            # => "::"
     def const_regexp(camel_cased_word) #:nodoc:
-      parts = camel_cased_word.split("::")
+      parts = camel_cased_word.split("::".freeze)
 
       return Regexp.escape(camel_cased_word) if parts.blank?
 
@@ -372,7 +372,7 @@ module ActiveSupport
     def apply_inflections(word, rules)
       result = word.to_s.dup
 
-      if word.empty? || inflections.uncountables.include?(result.downcase[/\b\w+\Z/])
+      if word.empty? || inflections.uncountables.uncountable?(result)
         result
       else
         rules.each { |(rule, replacement)| break if result.sub!(rule, replacement) }
diff --git a/activesupport/lib/active_support/inflector/transliterate.rb b/activesupport/lib/active_support/inflector/transliterate.rb
index edea142e82..7b28eeb6e2 100644
--- a/activesupport/lib/active_support/inflector/transliterate.rb
+++ b/activesupport/lib/active_support/inflector/transliterate.rb
@@ -58,7 +58,7 @@ module ActiveSupport
     #   I18n.locale = :de
     #   transliterate('Jürgen')
     #   # => "Juergen"
-    def transliterate(string, replacement = "?")
+    def transliterate(string, replacement = "?".freeze)
       I18n.transliterate(ActiveSupport::Multibyte::Unicode.normalize(
         ActiveSupport::Multibyte::Unicode.tidy_bytes(string), :c),
           :replacement => replacement)
@@ -75,13 +75,21 @@ module ActiveSupport
       # Turn unwanted chars into the separator
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, sep)
       unless sep.nil? || sep.empty?
-        re_sep = Regexp.escape(sep)
+        if sep == "-".freeze
+          re_duplicate_seperator        = /-{2,}/
+          re_leading_trailing_separator = /^-|-$/i
+        else
+          re_sep = Regexp.escape(sep)
+          re_duplicate_seperator        = /#{re_sep}{2,}/
+          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
+        end
         # No more than one of the separator in a row.
-        parameterized_string.gsub!(/#{re_sep}{2,}/, sep)
+        parameterized_string.gsub!(re_duplicate_seperator, sep)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(/^#{re_sep}|#{re_sep}$/i, '')
+        parameterized_string.gsub!(re_leading_trailing_separator, ''.freeze)
       end
-      parameterized_string.downcase
+      parameterized_string.downcase!
+      parameterized_string
     end
   end
 end
diff --git a/activesupport/lib/active_support/log_subscriber/test_helper.rb b/activesupport/lib/active_support/log_subscriber/test_helper.rb
index 38b3b1f960..cbc20c103d 100644
--- a/activesupport/lib/active_support/log_subscriber/test_helper.rb
+++ b/activesupport/lib/active_support/log_subscriber/test_helper.rb
@@ -34,7 +34,7 @@ module ActiveSupport
     # you can collect them doing @logger.logged(level), where level is the level
     # used in logging, like info, debug, warn and so on.
     module TestHelper
-      def setup
+      def setup # :nodoc:
         @logger   = MockLogger.new
         @notifier = ActiveSupport::Notifications::Fanout.new
 
@@ -45,7 +45,7 @@ module ActiveSupport
         ActiveSupport::Notifications.notifier = @notifier
       end
 
-      def teardown
+      def teardown # :nodoc:
         set_logger(nil)
         ActiveSupport::Notifications.notifier = @old_notifier
       end
diff --git a/activesupport/lib/active_support/message_encryptor.rb b/activesupport/lib/active_support/message_encryptor.rb
index 92ab6fe648..c82a13511e 100644
--- a/activesupport/lib/active_support/message_encryptor.rb
+++ b/activesupport/lib/active_support/message_encryptor.rb
@@ -82,7 +82,7 @@ module ActiveSupport
 
     def _decrypt(encrypted_message)
       cipher = new_cipher
-      encrypted_data, iv = encrypted_message.split("--").map {|v| ::Base64.strict_decode64(v)}
+      encrypted_data, iv = encrypted_message.split("--".freeze).map {|v| ::Base64.strict_decode64(v)}
 
       cipher.decrypt
       cipher.key = @secret
diff --git a/activesupport/lib/active_support/message_verifier.rb b/activesupport/lib/active_support/message_verifier.rb
index b2a4404968..64c5232cf4 100644
--- a/activesupport/lib/active_support/message_verifier.rb
+++ b/activesupport/lib/active_support/message_verifier.rb
@@ -46,7 +46,7 @@ module ActiveSupport
     def valid_message?(signed_message)
       return if signed_message.nil? || !signed_message.valid_encoding? || signed_message.blank?
 
-      data, digest = signed_message.split("--")
+      data, digest = signed_message.split("--".freeze)
       data.present? && digest.present? && ActiveSupport::SecurityUtils.secure_compare(digest, generate_digest(data))
     end
 
@@ -74,7 +74,7 @@ module ActiveSupport
     def verified(signed_message)
       if valid_message?(signed_message)
         begin
-          data = signed_message.split("--")[0]
+          data = signed_message.split("--".freeze)[0]
           @serializer.load(decode(data))
         rescue ArgumentError => argument_error
           return if argument_error.message =~ %r{invalid base64}
diff --git a/activesupport/lib/active_support/multibyte/unicode.rb b/activesupport/lib/active_support/multibyte/unicode.rb
index 35efebc65f..b6c991a287 100644
--- a/activesupport/lib/active_support/multibyte/unicode.rb
+++ b/activesupport/lib/active_support/multibyte/unicode.rb
@@ -58,7 +58,7 @@ module ActiveSupport
       # Returns a regular expression pattern that matches the passed Unicode
       # codepoints.
       def self.codepoints_to_pattern(array_of_codepoints) #:nodoc:
-        array_of_codepoints.collect{ |e| [e].pack 'U*' }.join('|')
+        array_of_codepoints.collect{ |e| [e].pack 'U*'.freeze }.join('|'.freeze)
       end
       TRAILERS_PAT = /(#{codepoints_to_pattern(LEADERS_AND_TRAILERS)})+\Z/u
       LEADERS_PAT = /\A(#{codepoints_to_pattern(LEADERS_AND_TRAILERS)})+/u
@@ -273,7 +273,7 @@ module ActiveSupport
             compose(reorder_characters(decompose(:compatibility, codepoints)))
           else
             raise ArgumentError, "#{form} is not a valid normalization variant", caller
-        end.pack('U*')
+        end.pack('U*'.freeze)
       end
 
       def downcase(string)
@@ -338,7 +338,7 @@ module ActiveSupport
           end
 
           # Redefine the === method so we can write shorter rules for grapheme cluster breaks
-          @boundary.each do |k,_|
+          @boundary.each_key do |k|
             @boundary[k].instance_eval do
               def ===(other)
                 detect { |i| i === other } ? true : false
diff --git a/activesupport/lib/active_support/notifications/fanout.rb b/activesupport/lib/active_support/notifications/fanout.rb
index 6bf8c7d5de..0131fe2572 100644
--- a/activesupport/lib/active_support/notifications/fanout.rb
+++ b/activesupport/lib/active_support/notifications/fanout.rb
@@ -111,7 +111,7 @@ module ActiveSupport
           end
         end
 
-        class Timed < Evented
+        class Timed < Evented # :nodoc:
           def publish(name, *args)
             @delegate.call name, *args
           end
diff --git a/activesupport/lib/active_support/number_helper.rb b/activesupport/lib/active_support/number_helper.rb
index 258d9b34e1..38a9ce361d 100644
--- a/activesupport/lib/active_support/number_helper.rb
+++ b/activesupport/lib/active_support/number_helper.rb
@@ -220,8 +220,6 @@ module ActiveSupport
     # * <tt>:strip_insignificant_zeros</tt> - If +true+ removes
     #   insignificant zeros after the decimal separator (defaults to
     #   +true+)
-    # * <tt>:prefix</tt> - If +:si+ formats the number using the SI
-    #   prefix (defaults to :binary)
     #
     # ==== Examples
     #
diff --git a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
index ac0d20b454..a4a8690bcd 100644
--- a/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
+++ b/activesupport/lib/active_support/number_helper/number_to_human_size_converter.rb
@@ -7,6 +7,10 @@ module ActiveSupport
       self.validate_float = true
 
       def convert
+        if opts.key?(:prefix)
+          ActiveSupport::Deprecation.warn('The :prefix option of `number_to_human_size` is deprecated and will be removed in Rails 5.1 with no replacement.')
+        end
+
         @number = Float(number)
 
         # for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
diff --git a/activesupport/lib/active_support/testing/method_call_assertions.rb b/activesupport/lib/active_support/testing/method_call_assertions.rb
index e3cbe40308..fccaa54f40 100644
--- a/activesupport/lib/active_support/testing/method_call_assertions.rb
+++ b/activesupport/lib/active_support/testing/method_call_assertions.rb
@@ -1,11 +1,13 @@
+require 'minitest/mock'
+
 module ActiveSupport
   module Testing
     module MethodCallAssertions # :nodoc:
       private
-        def assert_called(object, method_name, message = nil, times: 1)
+        def assert_called(object, method_name, message = nil, times: 1, returns: nil)
           times_called = 0
 
-          object.stub(method_name, -> { times_called += 1 }) { yield }
+          object.stub(method_name, proc { times_called += 1; returns }) { yield }
 
           error = "Expected #{method_name} to be called #{times} times, " \
             "but was called #{times_called} times"
@@ -30,6 +32,10 @@ module ActiveSupport
         def assert_not_called(object, method_name, message = nil, &block)
           assert_called(object, method_name, message, times: 0, &block)
         end
+
+        def stub_any_instance(klass, instance: klass.new)
+          klass.stub(:new, instance) { yield instance }
+        end
     end
   end
-end
\ No newline at end of file
+end
diff --git a/activesupport/lib/active_support/time_with_zone.rb b/activesupport/lib/active_support/time_with_zone.rb
index 412c72d27c..f8f1b9ac2c 100644
--- a/activesupport/lib/active_support/time_with_zone.rb
+++ b/activesupport/lib/active_support/time_with_zone.rb
@@ -247,7 +247,7 @@ module ActiveSupport
     end
 
     def eql?(other)
-      utc.eql?(other)
+      other.eql?(utc)
     end
 
     def hash
diff --git a/activesupport/test/core_ext/hash_ext_test.rb b/activesupport/test/core_ext/hash_ext_test.rb
index 663f782611..4624338df1 100644
--- a/activesupport/test/core_ext/hash_ext_test.rb
+++ b/activesupport/test/core_ext/hash_ext_test.rb
@@ -551,6 +551,11 @@ class HashExtTest < ActiveSupport::TestCase
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
   end
 
+  def test_indifferent_select_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).select
+    assert_instance_of Enumerator, enum
+  end
+
   def test_indifferent_select_returns_a_hash_when_unchanged
     hash = ActiveSupport::HashWithIndifferentAccess.new(@strings).select {|k,v| true}
 
@@ -572,6 +577,11 @@ class HashExtTest < ActiveSupport::TestCase
     assert_instance_of ActiveSupport::HashWithIndifferentAccess, hash
   end
 
+  def test_indifferent_reject_returns_enumerator
+    enum = ActiveSupport::HashWithIndifferentAccess.new(@strings).reject
+    assert_instance_of Enumerator, enum
+  end
+
   def test_indifferent_reject_bang
     indifferent_strings = ActiveSupport::HashWithIndifferentAccess.new(@strings)
     indifferent_strings.reject! {|k,v| v != 1}
diff --git a/activesupport/test/core_ext/module/attribute_accessor_test.rb b/activesupport/test/core_ext/module/attribute_accessor_test.rb
index 48f3cc579f..128c5e3d1a 100644
--- a/activesupport/test/core_ext/module/attribute_accessor_test.rb
+++ b/activesupport/test/core_ext/module/attribute_accessor_test.rb
@@ -76,4 +76,10 @@ class ModuleAttributeAccessorTest < ActiveSupport::TestCase
     assert_equal 'default_reader_value', @module.defr
     assert_equal 'default_writer_value', @module.class_variable_get('@@defw')
   end
+
+  def test_should_not_invoke_default_value_block_multiple_times
+    count = 0
+    @module.cattr_accessor(:defcount){ count += 1 }
+    assert_equal 1, count
+  end
 end
diff --git a/activesupport/test/core_ext/numeric_ext_test.rb b/activesupport/test/core_ext/numeric_ext_test.rb
index 2d8796179e..0ff8f0f89b 100644
--- a/activesupport/test/core_ext/numeric_ext_test.rb
+++ b/activesupport/test/core_ext/numeric_ext_test.rb
@@ -280,14 +280,16 @@ class NumericExtFormattingTest < ActiveSupport::TestCase
   end
 
   def test_to_s__human_size_with_si_prefix
-    assert_equal '3 Bytes',    3.14159265.to_s(:human_size, :prefix => :si)
-    assert_equal '123 Bytes',  123.0.to_s(:human_size, :prefix => :si)
-    assert_equal '123 Bytes',  123.to_s(:human_size, :prefix => :si)
-    assert_equal '1.23 KB',    1234.to_s(:human_size, :prefix => :si)
-    assert_equal '12.3 KB',    12345.to_s(:human_size, :prefix => :si)
-    assert_equal '1.23 MB',    1234567.to_s(:human_size, :prefix => :si)
-    assert_equal '1.23 GB',    1234567890.to_s(:human_size, :prefix => :si)
-    assert_equal '1.23 TB',    1234567890123.to_s(:human_size, :prefix => :si)
+    assert_deprecated do
+      assert_equal '3 Bytes',    3.14159265.to_s(:human_size, :prefix => :si)
+      assert_equal '123 Bytes',  123.0.to_s(:human_size, :prefix => :si)
+      assert_equal '123 Bytes',  123.to_s(:human_size, :prefix => :si)
+      assert_equal '1.23 KB',    1234.to_s(:human_size, :prefix => :si)
+      assert_equal '12.3 KB',    12345.to_s(:human_size, :prefix => :si)
+      assert_equal '1.23 MB',    1234567.to_s(:human_size, :prefix => :si)
+      assert_equal '1.23 GB',    1234567890.to_s(:human_size, :prefix => :si)
+      assert_equal '1.23 TB',    1234567890123.to_s(:human_size, :prefix => :si)
+    end
   end
 
   def test_to_s__human_size_with_options_hash
diff --git a/activesupport/test/core_ext/object/json_gem_encoding_test.rb b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
new file mode 100644
index 0000000000..02ab17fb64
--- /dev/null
+++ b/activesupport/test/core_ext/object/json_gem_encoding_test.rb
@@ -0,0 +1,66 @@
+require 'abstract_unit'
+require 'json'
+require 'json/encoding_test_cases'
+
+# These test cases were added to test that we do not interfere with json gem's
+# output when the AS encoder is loaded, primarily for problems reported in
+# #20775. They need to be executed in isolation to reproduce the scenario
+# correctly, because other test cases might have already loaded additional
+# dependencies.
+
+# The AS::JSON encoder requires the BigDecimal core_ext, which, unfortunately,
+# changes the BigDecimal#to_s output, and consequently the JSON gem output. So
+# we need to require this unfront to ensure we don't get a false failure, but
+# ideally we should just fix the BigDecimal core_ext to not change to_s without
+# arguments.
+require 'active_support/core_ext/big_decimal'
+
+class JsonGemEncodingTest < ActiveSupport::TestCase
+  include ActiveSupport::Testing::Isolation
+
+  JSONTest::EncodingTestCases.constants.each_with_index do |name|
+    JSONTest::EncodingTestCases.const_get(name).each_with_index do |(subject, _), i|
+      test("#{name[0..-6].underscore} #{i}") do
+        assert_same_with_or_without_active_support(subject)
+      end
+    end
+  end
+
+  class CustomToJson
+    def to_json(*)
+      '"custom"'
+    end
+  end
+
+  test "custom to_json" do
+    assert_same_with_or_without_active_support(CustomToJson.new)
+  end
+
+  private
+    def require_or_skip(file)
+      require(file) || skip("'#{file}' was already loaded")
+    end
+
+    def assert_same_with_or_without_active_support(subject)
+      begin
+        expected = JSON.generate(subject, quirks_mode: true)
+      rescue JSON::GeneratorError => e
+        exception = e
+      end
+
+      require_or_skip 'active_support/core_ext/object/json'
+
+      if exception
+        assert_raises_with_message JSON::GeneratorError, e.message do
+          JSON.generate(subject, quirks_mode: true)
+        end
+      else
+        assert_equal expected, JSON.generate(subject, quirks_mode: true)
+      end
+    end
+
+    def assert_raises_with_message(exception_class, message, &block)
+      err = assert_raises(exception_class) { block.call }
+      assert_match message, err.message
+    end
+end
diff --git a/activesupport/test/core_ext/time_with_zone_test.rb b/activesupport/test/core_ext/time_with_zone_test.rb
index 477a42114b..ccb7f02331 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -253,10 +253,14 @@ class TimeWithZoneTest < ActiveSupport::TestCase
   end
 
   def test_eql?
+    assert_equal true, @twz.eql?(@twz.dup)
     assert_equal true, @twz.eql?(Time.utc(2000))
     assert_equal true, @twz.eql?( ActiveSupport::TimeWithZone.new(Time.utc(2000), ActiveSupport::TimeZone["Hawaii"]) )
     assert_equal false, @twz.eql?( Time.utc(2000, 1, 1, 0, 0, 1) )
     assert_equal false, @twz.eql?( DateTime.civil(1999, 12, 31, 23, 59, 59) )
+
+    other_twz = ActiveSupport::TimeWithZone.new(DateTime.now.utc, @time_zone)
+    assert_equal true, other_twz.eql?(other_twz.dup)
   end
 
   def test_hash
diff --git a/activesupport/test/json/encoding_test.rb b/activesupport/test/json/encoding_test.rb
index ee47b97a8a..9f4b62fd8b 100644
--- a/activesupport/test/json/encoding_test.rb
+++ b/activesupport/test/json/encoding_test.rb
@@ -4,122 +4,24 @@ require 'active_support/core_ext/string/inflections'
 require 'active_support/json'
 require 'active_support/time'
 require 'time_zone_test_helpers'
+require 'json/encoding_test_cases'
 
 class TestJSONEncoding < ActiveSupport::TestCase
   include TimeZoneTestHelpers
 
-  class Foo
-    def initialize(a, b)
-      @a, @b = a, b
-    end
-  end
-
-  class Hashlike
-    def to_hash
-      { :foo => "hello", :bar => "world" }
-    end
-  end
-
-  class Custom
-    def initialize(serialized)
-      @serialized = serialized
-    end
-
-    def as_json(options = nil)
-      @serialized
-    end
-  end
-
-  class CustomWithOptions
-    attr_accessor :foo, :bar
-
-    def as_json(options={})
-      options[:only] = %w(foo bar)
-      super(options)
-    end
-  end
-
-  class OptionsTest
-    def as_json(options = :default)
-      options
-    end
-  end
-
-  class HashWithAsJson < Hash
-    attr_accessor :as_json_called
-
-    def initialize(*)
-      super
-    end
-
-    def as_json(options={})
-      @as_json_called = true
-      super
-    end
-  end
-
-  TrueTests     = [[ true,  %(true)  ]]
-  FalseTests    = [[ false, %(false) ]]
-  NilTests      = [[ nil,   %(null)  ]]
-  NumericTests  = [[ 1,     %(1)     ],
-                   [ 2.5,   %(2.5)   ],
-                   [ 0.0/0.0,   %(null) ],
-                   [ 1.0/0.0,   %(null) ],
-                   [ -1.0/0.0,  %(null) ],
-                   [ BigDecimal('0.0')/BigDecimal('0.0'),  %(null) ],
-                   [ BigDecimal('2.5'), %("#{BigDecimal('2.5')}") ]]
-
-  StringTests   = [[ 'this is the <string>',     %("this is the \\u003cstring\\u003e")],
-                   [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
-                   [ 'http://test.host/posts/1', %("http://test.host/posts/1")],
-                   [ "Control characters: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\u2028\u2029",
-                     %("Control characters: \\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u2028\\u2029") ]]
-
-  ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])          ],
-                   [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
-
-  RangeTests    = [[ 1..2,     %("1..2")],
-                   [ 1...2,    %("1...2")],
-                   [ 1.5..2.5, %("1.5..2.5")]]
-
-  SymbolTests   = [[ :a,     %("a")    ],
-                   [ :this,  %("this") ],
-                   [ :"a b", %("a b")  ]]
-
-  ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
-  HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
-  CustomTests   = [[ Custom.new("custom"), '"custom"' ],
-                   [ Custom.new(nil), 'null' ],
-                   [ Custom.new(:a), '"a"' ],
-                   [ Custom.new([ :foo, "bar" ]), '["foo","bar"]' ],
-                   [ Custom.new({ :foo => "hello", :bar => "world" }), '{"bar":"world","foo":"hello"}' ],
-                   [ Custom.new(Hashlike.new), '{"bar":"world","foo":"hello"}' ],
-                   [ Custom.new(Custom.new(Custom.new(:a))), '"a"' ]]
-
-  RegexpTests   = [[ /^a/, '"(?-mix:^a)"' ], [/^\w{1,2}[a-z]+/ix, '"(?ix-m:^\\\\w{1,2}[a-z]+)"']]
-
-  DateTests     = [[ Date.new(2005,2,1), %("2005/02/01") ]]
-  TimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-  DateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
-
-  StandardDateTests     = [[ Date.new(2005,2,1), %("2005-02-01") ]]
-  StandardTimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000Z") ]]
-  StandardDateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000+00:00") ]]
-  StandardStringTests   = [[ 'this is the <string>', %("this is the <string>")]]
-
   def sorted_json(json)
     return json unless json =~ /^\{.*\}$/
     '{' + json[1..-2].split(',').sort.join(',') + '}'
   end
 
-  constants.grep(/Tests$/).each do |class_tests|
+  JSONTest::EncodingTestCases.constants.each do |class_tests|
     define_method("test_#{class_tests[0..-6].underscore}") do
       begin
         prev = ActiveSupport.use_standard_json_time_format
 
         ActiveSupport.escape_html_entities_in_json  = class_tests !~ /^Standard/
         ActiveSupport.use_standard_json_time_format = class_tests =~ /^Standard/
-        self.class.const_get(class_tests).each do |pair|
+        JSONTest::EncodingTestCases.const_get(class_tests).each do |pair|
           assert_equal pair.last, sorted_json(ActiveSupport::JSON.encode(pair.first))
         end
       ensure
@@ -224,7 +126,7 @@ class TestJSONEncoding < ActiveSupport::TestCase
   end
 
   def test_hash_like_with_options
-    h = Hashlike.new
+    h = JSONTest::Hashlike.new
     json = h.to_json :only => [:foo]
 
     assert_equal({"foo"=>"hello"}, JSON.parse(json))
@@ -345,6 +247,15 @@ class TestJSONEncoding < ActiveSupport::TestCase
     assert_equal(%([{"address":{"city":"London"}},{"address":{"city":"Paris"}}]), json)
   end
 
+  class CustomWithOptions
+    attr_accessor :foo, :bar
+
+    def as_json(options={})
+      options[:only] = %w(foo bar)
+      super(options)
+    end
+  end
+
   def test_hash_to_json_should_not_keep_options_around
     f = CustomWithOptions.new
     f.foo = "hello"
@@ -365,6 +276,12 @@ class TestJSONEncoding < ActiveSupport::TestCase
                   {"foo"=>"other_foo","test"=>"other_test"}], ActiveSupport::JSON.decode(array.to_json))
   end
 
+  class OptionsTest
+    def as_json(options = :default)
+      options
+    end
+  end
+
   def test_hash_as_json_without_options
     json = { foo: OptionsTest.new }.as_json
     assert_equal({"foo" => :default}, json)
@@ -412,6 +329,19 @@ class TestJSONEncoding < ActiveSupport::TestCase
     assert_equal false, false.as_json
   end
 
+  class HashWithAsJson < Hash
+    attr_accessor :as_json_called
+
+    def initialize(*)
+      super
+    end
+
+    def as_json(options={})
+      @as_json_called = true
+      super
+    end
+  end
+
   def test_json_gem_dump_by_passing_active_support_encoder
     h = HashWithAsJson.new
     h[:foo] = "hello"
diff --git a/activesupport/test/json/encoding_test_cases.rb b/activesupport/test/json/encoding_test_cases.rb
new file mode 100644
index 0000000000..0159ba8606
--- /dev/null
+++ b/activesupport/test/json/encoding_test_cases.rb
@@ -0,0 +1,88 @@
+require 'bigdecimal'
+
+module JSONTest
+  class Foo
+    def initialize(a, b)
+      @a, @b = a, b
+    end
+  end
+
+  class Hashlike
+    def to_hash
+      { :foo => "hello", :bar => "world" }
+    end
+  end
+
+  class Custom
+    def initialize(serialized)
+      @serialized = serialized
+    end
+
+    def as_json(options = nil)
+      @serialized
+    end
+  end
+
+  class MyStruct < Struct.new(:name, :value)
+    def initialize(*)
+      @unused = "unused instance variable"
+      super
+    end
+  end
+
+  module EncodingTestCases
+    TrueTests     = [[ true,  %(true)  ]]
+    FalseTests    = [[ false, %(false) ]]
+    NilTests      = [[ nil,   %(null)  ]]
+    NumericTests  = [[ 1,     %(1)     ],
+                     [ 2.5,   %(2.5)   ],
+                     [ 0.0/0.0,   %(null) ],
+                     [ 1.0/0.0,   %(null) ],
+                     [ -1.0/0.0,  %(null) ],
+                     [ BigDecimal('0.0')/BigDecimal('0.0'),  %(null) ],
+                     [ BigDecimal('2.5'), %("#{BigDecimal('2.5')}") ]]
+
+    StringTests   = [[ 'this is the <string>',     %("this is the \\u003cstring\\u003e")],
+                     [ 'a "string" with quotes & an ampersand', %("a \\"string\\" with quotes \\u0026 an ampersand") ],
+                     [ 'http://test.host/posts/1', %("http://test.host/posts/1")],
+                     [ "Control characters: \x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\u2028\u2029",
+                       %("Control characters: \\u0000\\u0001\\u0002\\u0003\\u0004\\u0005\\u0006\\u0007\\b\\t\\n\\u000b\\f\\r\\u000e\\u000f\\u0010\\u0011\\u0012\\u0013\\u0014\\u0015\\u0016\\u0017\\u0018\\u0019\\u001a\\u001b\\u001c\\u001d\\u001e\\u001f\\u2028\\u2029") ]]
+
+    ArrayTests    = [[ ['a', 'b', 'c'],          %([\"a\",\"b\",\"c\"])        ],
+                     [ [1, 'a', :b, nil, false], %([1,\"a\",\"b\",null,false]) ]]
+
+    HashTests     = [[ {foo: "bar"}, %({\"foo\":\"bar\"}) ],
+                     [ {1 => 1, 2 => 'a', 3 => :b, 4 => nil, 5 => false}, %({\"1\":1,\"2\":\"a\",\"3\":\"b\",\"4\":null,\"5\":false}) ]]
+
+    RangeTests    = [[ 1..2,     %("1..2")],
+                     [ 1...2,    %("1...2")],
+                     [ 1.5..2.5, %("1.5..2.5")]]
+
+    SymbolTests   = [[ :a,     %("a")    ],
+                     [ :this,  %("this") ],
+                     [ :"a b", %("a b")  ]]
+
+    ObjectTests   = [[ Foo.new(1, 2), %({\"a\":1,\"b\":2}) ]]
+    HashlikeTests = [[ Hashlike.new, %({\"bar\":\"world\",\"foo\":\"hello\"}) ]]
+    StructTests   = [[ MyStruct.new(:foo, "bar"), %({\"name\":\"foo\",\"value\":\"bar\"}) ],
+                     [ MyStruct.new(nil, nil), %({\"name\":null,\"value\":null}) ]]
+    CustomTests   = [[ Custom.new("custom"), '"custom"' ],
+                     [ Custom.new(nil), 'null' ],
+                     [ Custom.new(:a), '"a"' ],
+                     [ Custom.new([ :foo, "bar" ]), '["foo","bar"]' ],
+                     [ Custom.new({ :foo => "hello", :bar => "world" }), '{"bar":"world","foo":"hello"}' ],
+                     [ Custom.new(Hashlike.new), '{"bar":"world","foo":"hello"}' ],
+                     [ Custom.new(Custom.new(Custom.new(:a))), '"a"' ]]
+
+    RegexpTests   = [[ /^a/, '"(?-mix:^a)"' ], [/^\w{1,2}[a-z]+/ix, '"(?ix-m:^\\\\w{1,2}[a-z]+)"']]
+
+    DateTests     = [[ Date.new(2005,2,1), %("2005/02/01") ]]
+    TimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
+    DateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005/02/01 15:15:10 +0000") ]]
+
+    StandardDateTests     = [[ Date.new(2005,2,1), %("2005-02-01") ]]
+    StandardTimeTests     = [[ Time.utc(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000Z") ]]
+    StandardDateTimeTests = [[ DateTime.civil(2005,2,1,15,15,10), %("2005-02-01T15:15:10.000+00:00") ]]
+    StandardStringTests   = [[ 'this is the <string>', %("this is the <string>")]]
+  end
+end
diff --git a/activesupport/test/number_helper_test.rb b/activesupport/test/number_helper_test.rb
index 83efbffdfb..cb5230c4eb 100644
--- a/activesupport/test/number_helper_test.rb
+++ b/activesupport/test/number_helper_test.rb
@@ -234,15 +234,17 @@ module ActiveSupport
       end
 
       def test_number_to_human_size_with_si_prefix
-        [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
-          assert_equal '3 Bytes',    number_helper.number_to_human_size(3.14159265, :prefix => :si)
-          assert_equal '123 Bytes',  number_helper.number_to_human_size(123.0, :prefix => :si)
-          assert_equal '123 Bytes',  number_helper.number_to_human_size(123, :prefix => :si)
-          assert_equal '1.23 KB',    number_helper.number_to_human_size(1234, :prefix => :si)
-          assert_equal '12.3 KB',    number_helper.number_to_human_size(12345, :prefix => :si)
-          assert_equal '1.23 MB',    number_helper.number_to_human_size(1234567, :prefix => :si)
-          assert_equal '1.23 GB',    number_helper.number_to_human_size(1234567890, :prefix => :si)
-          assert_equal '1.23 TB',    number_helper.number_to_human_size(1234567890123, :prefix => :si)
+        assert_deprecated do
+          [@instance_with_helpers, TestClassWithClassNumberHelpers, ActiveSupport::NumberHelper].each do |number_helper|
+            assert_equal '3 Bytes',    number_helper.number_to_human_size(3.14159265, :prefix => :si)
+            assert_equal '123 Bytes',  number_helper.number_to_human_size(123.0, :prefix => :si)
+            assert_equal '123 Bytes',  number_helper.number_to_human_size(123, :prefix => :si)
+            assert_equal '1.23 KB',    number_helper.number_to_human_size(1234, :prefix => :si)
+            assert_equal '12.3 KB',    number_helper.number_to_human_size(12345, :prefix => :si)
+            assert_equal '1.23 MB',    number_helper.number_to_human_size(1234567, :prefix => :si)
+            assert_equal '1.23 GB',    number_helper.number_to_human_size(1234567890, :prefix => :si)
+            assert_equal '1.23 TB',    number_helper.number_to_human_size(1234567890123, :prefix => :si)
+          end
         end
       end
 
diff --git a/activesupport/test/share_lock_test.rb b/activesupport/test/share_lock_test.rb
new file mode 100644
index 0000000000..ad41db608b
--- /dev/null
+++ b/activesupport/test/share_lock_test.rb
@@ -0,0 +1,333 @@
+require 'abstract_unit'
+require 'concurrent/atomics'
+require 'active_support/concurrency/share_lock'
+
+class ShareLockTest < ActiveSupport::TestCase
+  def setup
+    @lock = ActiveSupport::Concurrency::ShareLock.new
+  end
+
+  def test_reentrancy
+    thread = Thread.new do
+      @lock.sharing   { @lock.sharing   {} }
+      @lock.exclusive { @lock.exclusive {} }
+    end
+    assert_threads_not_stuck thread
+  end
+
+  def test_sharing_doesnt_block
+    with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_latch|
+      assert_threads_not_stuck(Thread.new {@lock.sharing {} })
+    end
+  end
+
+  def test_sharing_blocks_exclusive
+    with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+      @lock.exclusive(no_wait: true) { flunk } # polling should fail
+      exclusive_thread = Thread.new { @lock.exclusive {} }
+      assert_threads_stuck_but_releasable_by_latch exclusive_thread, sharing_thread_release_latch
+    end
+  end
+
+  def test_exclusive_blocks_sharing
+    with_thread_waiting_in_lock_section(:exclusive) do |exclusive_thread_release_latch|
+      sharing_thread = Thread.new { @lock.sharing {} }
+      assert_threads_stuck_but_releasable_by_latch sharing_thread, exclusive_thread_release_latch
+    end
+  end
+
+  def test_multiple_exlusives_are_able_to_progress
+    with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+      exclusive_threads = (1..2).map do
+        Thread.new do
+          @lock.exclusive {}
+        end
+      end
+
+      assert_threads_stuck_but_releasable_by_latch exclusive_threads, sharing_thread_release_latch
+    end
+  end
+
+  def test_sharing_is_upgradeable_to_exclusive
+    upgrading_thread = Thread.new do
+      @lock.sharing do
+        @lock.exclusive {}
+      end
+    end
+    assert_threads_not_stuck upgrading_thread
+  end
+
+  def test_exclusive_upgrade_waits_for_other_sharers_to_leave
+    with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+      in_sharing = Concurrent::CountDownLatch.new
+
+      upgrading_thread = Thread.new do
+        @lock.sharing do
+          in_sharing.count_down
+          @lock.exclusive {}
+        end
+      end
+
+      in_sharing.wait
+      assert_threads_stuck_but_releasable_by_latch upgrading_thread, sharing_thread_release_latch
+    end
+  end
+
+  def test_exclusive_matching_purpose
+    [true, false].each do |use_upgrading|
+      with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+        exclusive_threads = (1..2).map do
+          Thread.new do
+            @lock.send(use_upgrading ? :sharing : :tap) do
+              @lock.exclusive(purpose: :load, compatible: [:load, :unload]) {}
+            end
+          end
+        end
+
+        assert_threads_stuck_but_releasable_by_latch exclusive_threads, sharing_thread_release_latch
+      end
+    end
+  end
+
+  def test_killed_thread_loses_lock
+    with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+      thread = Thread.new do
+        @lock.sharing do
+          @lock.exclusive {}
+        end
+      end
+
+      assert_threads_stuck thread
+      thread.kill
+
+      sharing_thread_release_latch.count_down
+
+      thread = Thread.new do
+        @lock.exclusive {}
+      end
+
+      assert_threads_not_stuck thread
+    end
+  end
+
+  def test_exclusive_conflicting_purpose
+    [true, false].each do |use_upgrading|
+      with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+        begin
+          conflicting_exclusive_threads = [
+            Thread.new do
+              @lock.send(use_upgrading ? :sharing : :tap) do
+                @lock.exclusive(purpose: :red, compatible: [:green, :purple]) {}
+              end
+            end,
+            Thread.new do
+              @lock.send(use_upgrading ? :sharing : :tap) do
+                @lock.exclusive(purpose: :blue, compatible: [:green]) {}
+              end
+            end
+          ]
+
+          assert_threads_stuck conflicting_exclusive_threads # wait for threads to get into their respective `exclusive {}` blocks
+
+          # This thread will be stuck as long as any other thread is in
+          # a sharing block. While it's blocked, it holds no lock, so it
+          # doesn't interfere with any other attempts.
+          no_purpose_thread = Thread.new do
+            @lock.exclusive {}
+          end
+          assert_threads_stuck no_purpose_thread
+
+          # This thread is compatible with both of the "primary"
+          # attempts above. It's initially stuck on the outer share
+          # lock, but as soon as that's released, it can run --
+          # regardless of whether those threads hold share locks.
+          compatible_thread = Thread.new do
+            @lock.exclusive(purpose: :green, compatible: []) {}
+          end
+          assert_threads_stuck compatible_thread
+
+          assert_threads_stuck conflicting_exclusive_threads
+
+          sharing_thread_release_latch.count_down
+
+          assert_threads_not_stuck compatible_thread # compatible thread is now able to squeak through
+
+          if use_upgrading
+            # The "primary" threads both each hold a share lock, and are
+            # mutually incompatible; they're still stuck.
+            assert_threads_stuck conflicting_exclusive_threads
+
+            # The thread without a specified purpose is also stuck; it's
+            # not compatible with anything.
+            assert_threads_stuck no_purpose_thread
+          else
+            # As the primaries didn't hold a share lock, as soon as the
+            # outer one was released, all the exclusive locks are free
+            # to be acquired in turn.
+
+            assert_threads_not_stuck conflicting_exclusive_threads
+            assert_threads_not_stuck no_purpose_thread
+          end
+        ensure
+          conflicting_exclusive_threads.each(&:kill)
+          no_purpose_thread.kill
+        end
+      end
+    end
+  end
+
+  def test_exclusive_ordering
+    scratch_pad       = []
+    scratch_pad_mutex = Mutex.new
+
+    load_params   = [:load,   [:load]]
+    unload_params = [:unload, [:unload, :load]]
+
+    [load_params, load_params, unload_params, unload_params].permutation do |thread_params|
+      with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+        threads = thread_params.map do |purpose, compatible|
+          Thread.new do
+            @lock.sharing do
+              @lock.exclusive(purpose: purpose, compatible: compatible) do
+                scratch_pad_mutex.synchronize { scratch_pad << purpose }
+              end
+            end
+          end
+        end
+
+        sleep(0.01)
+        scratch_pad_mutex.synchronize { assert_empty scratch_pad }
+
+        sharing_thread_release_latch.count_down
+
+        assert_threads_not_stuck threads
+        scratch_pad_mutex.synchronize do
+          assert_equal [:load, :load, :unload, :unload], scratch_pad
+          scratch_pad.clear
+        end
+      end
+    end
+  end
+
+  def test_in_shared_section_incompatible_non_upgrading_threads_cannot_preempt_upgrading_threads
+    scratch_pad       = []
+    scratch_pad_mutex = Mutex.new
+
+    upgrading_load_params       = [:load,   [:load],          true]
+    non_upgrading_unload_params = [:unload, [:load, :unload], false]
+
+    [upgrading_load_params, non_upgrading_unload_params].permutation do |thread_params|
+      with_thread_waiting_in_lock_section(:sharing) do |sharing_thread_release_latch|
+        threads = thread_params.map do |purpose, compatible, use_upgrading|
+          Thread.new do
+            @lock.send(use_upgrading ? :sharing : :tap) do
+              @lock.exclusive(purpose: purpose, compatible: compatible) do
+                scratch_pad_mutex.synchronize { scratch_pad << purpose }
+              end
+            end
+          end
+        end
+
+        assert_threads_stuck threads
+        scratch_pad_mutex.synchronize { assert_empty scratch_pad }
+
+        sharing_thread_release_latch.count_down
+
+        assert_threads_not_stuck threads
+        scratch_pad_mutex.synchronize do
+          assert_equal [:load, :unload], scratch_pad
+          scratch_pad.clear
+        end
+      end
+    end
+  end
+
+  private
+
+  module CustomAssertions
+    SUFFICIENT_TIMEOUT = 0.2
+
+    private
+
+    def assert_threads_stuck_but_releasable_by_latch(threads, latch)
+      assert_threads_stuck threads
+      latch.count_down
+      assert_threads_not_stuck threads
+    end
+
+    def assert_threads_stuck(threads)
+      sleep(SUFFICIENT_TIMEOUT) # give threads time to do their business
+      assert(Array(threads).all? { |t| t.join(0.001).nil? })
+    end
+
+    def assert_threads_not_stuck(threads)
+      assert(Array(threads).all? { |t| t.join(SUFFICIENT_TIMEOUT) })
+    end
+  end
+
+  class CustomAssertionsTest < ActiveSupport::TestCase
+    include CustomAssertions
+
+    def setup
+      @latch = Concurrent::CountDownLatch.new
+      @thread = Thread.new { @latch.wait }
+    end
+
+    def teardown
+      @latch.count_down
+      @thread.join
+    end
+
+    def test_happy_path
+      assert_threads_stuck_but_releasable_by_latch @thread, @latch
+    end
+
+    def test_detects_stuck_thread
+      assert_raises(Minitest::Assertion) do
+        assert_threads_not_stuck @thread
+      end
+    end
+
+    def test_detects_free_thread
+      @latch.count_down
+      assert_raises(Minitest::Assertion) do
+        assert_threads_stuck @thread
+      end
+    end
+
+    def test_detects_already_released
+      @latch.count_down
+      assert_raises(Minitest::Assertion) do
+        assert_threads_stuck_but_releasable_by_latch @thread, @latch
+      end
+    end
+
+    def test_detects_remains_latched
+      another_latch = Concurrent::CountDownLatch.new
+      assert_raises(Minitest::Assertion) do
+        assert_threads_stuck_but_releasable_by_latch @thread, another_latch
+      end
+    end
+  end
+
+  include CustomAssertions
+
+  def with_thread_waiting_in_lock_section(lock_section)
+    in_section      = Concurrent::CountDownLatch.new
+    section_release = Concurrent::CountDownLatch.new
+
+    stuck_thread = Thread.new do
+      @lock.send(lock_section) do
+        in_section.count_down
+        section_release.wait
+      end
+    end
+
+    in_section.wait
+
+    yield section_release
+  ensure
+    section_release.count_down
+    stuck_thread.join # clean up
+  end
+end
diff --git a/activesupport/test/testing/method_call_assertions_test.rb b/activesupport/test/testing/method_call_assertions_test.rb
index a9908aea0d..3e5ba7c079 100644
--- a/activesupport/test/testing/method_call_assertions_test.rb
+++ b/activesupport/test/testing/method_call_assertions_test.rb
@@ -27,6 +27,18 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
     end
   end
 
+  def test_assert_called_method_with_arguments
+    assert_called(@object, :<<) do
+      @object << 2
+    end
+  end
+
+  def test_assert_called_returns
+    assert_called(@object, :increment, returns: 10) do
+      assert_equal 10, @object.increment
+    end
+  end
+
   def test_assert_called_failure
     error = assert_raises(Minitest::Assertion) do
       assert_called(@object, :increment) do
@@ -95,4 +107,17 @@ class MethodCallAssertionsTest < ActiveSupport::TestCase
 
     assert_equal "Expected increment to be called 0 times, but was called 1 times.\nExpected: 0\n  Actual: 1", error.message
   end
+
+  def test_stub_any_instance
+    stub_any_instance(Level) do |instance|
+      assert_equal instance, Level.new
+    end
+  end
+
+  def test_stub_any_instance_with_instance
+    stub_any_instance(Level, instance: @object) do |instance|
+      assert_equal @object, instance
+      assert_equal instance, Level.new
+    end
+  end
 end