Merge branch 'master' into activestorage-guide

29 files changed, 909 insertions, 72 deletions

diff --git a/activesupport/CHANGELOG.md b/activesupport/CHANGELOG.md
index 780c887b49..88bbafc3a8 100644
--- a/activesupport/CHANGELOG.md
+++ b/activesupport/CHANGELOG.md
@@ -1,3 +1,95 @@
+*   MemCacheStore: Support expiring counters.
+
+    Pass `expires_in: [seconds]` to `#increment` and `#decrement` options
+    to set the Memcached TTL (time-to-live) if the counter doesn't exist.
+    If the counter exists, Memcached doesn't extend its expiry when it's
+    incremented or decremented.
+
+    ```
+    Rails.cache.increment("my_counter", 1, expires_in: 2.minutes)
+    ```
+
+    *Takumasa Ochi*
+
+*   Handle `TZInfo::AmbiguousTime` errors
+
+    Make `ActiveSupport::TimeWithZone` match Ruby's handling of ambiguous
+    times by choosing the later period, e.g.
+
+    Ruby:
+    ```
+    ENV["TZ"] = "Europe/Moscow"
+    Time.local(2014, 10, 26, 1, 0, 0)   # => 2014-10-26 01:00:00 +0300
+    ```
+
+    Before:
+    ```
+    >> "2014-10-26 01:00:00".in_time_zone("Moscow")
+    TZInfo::AmbiguousTime: 26/10/2014 01:00 is an ambiguous local time.
+    ```
+
+    After:
+    ```
+    >> "2014-10-26 01:00:00".in_time_zone("Moscow")
+    => Sun, 26 Oct 2014 01:00:00 MSK +03:00
+    ```
+
+    Fixes #17395.
+
+    *Andrew White*
+
+*   Redis cache store.
+
+    ```
+    # Defaults to `redis://localhost:6379/0`. Only use for dev/test.
+    config.cache_store = :redis_cache_store
+
+    # Supports all common cache store options (:namespace, :compress,
+    # :compress_threshold, :expires_in, :race_condition_tool) and all
+    # Redis options.
+    cache_password = Rails.application.secrets.redis_cache_password
+    config.cache_store = :redis_cache_store, driver: :hiredis,
+      namespace: 'myapp-cache', compress: true, timeout: 1,
+      url: "redis://:#{cache_password}@myapp-cache-1:6379/0"
+
+    # Supports Redis::Distributed with multiple hosts
+    config.cache_store = :redis_cache_store, driver: :hiredis
+      namespace: 'myapp-cache', compress: true,
+      url: %w[
+        redis://myapp-cache-1:6379/0
+        redis://myapp-cache-1:6380/0
+        redis://myapp-cache-2:6379/0
+        redis://myapp-cache-2:6380/0
+        redis://myapp-cache-3:6379/0
+        redis://myapp-cache-3:6380/0
+      ]
+
+    # Or pass a builder block
+    config.cache_store = :redis_cache_store,
+      namespace: 'myapp-cache', compress: true,
+      redis: -> { Redis.new … }
+    ```
+
+    Deployment note: Take care to use a *dedicated Redis cache* rather
+    than pointing this at your existing Redis server. It won't cope well
+    with mixed usage patterns and it won't expire cache entries by default.
+
+    Redis cache server setup guide: https://redis.io/topics/lru-cache
+
+    *Jeremy Daer*
+
+*   Cache: Enable compression by default for values > 1kB.
+
+    Compression has long been available, but opt-in and at a 16kB threshold.
+    It wasn't enabled by default due to CPU cost. Today it's cheap and typical
+    cache data is eminently compressible, such as HTML or JSON fragments.
+    Compression dramatically reduces Memcached/Redis mem usage, which means
+    the same cache servers can store more data, which means higher hit rates.
+
+    To disable compression, pass `compress: false` to the initializer.
+
+    *Jeremy Daer*
+
 *   Allow `Range#include?` on TWZ ranges
 
     In #11474 we prevented TWZ ranges being iterated over which matched
@@ -6,9 +98,9 @@
     ruby/ruby@b061634 support was added for `include?` to use `cover?`
     for 'linear' objects. Since we have no way of making Ruby consider
     TWZ instances as 'linear' we have to override `Range#include?`.
-    
+
     Fixes #30799.
-    
+
     *Andrew White*
 
 *   Fix acronym support in `humanize`
diff --git a/activesupport/lib/active_support/cache.rb b/activesupport/lib/active_support/cache.rb
index 976104e0c4..395aa5e8f1 100644
--- a/activesupport/lib/active_support/cache.rb
+++ b/activesupport/lib/active_support/cache.rb
@@ -12,10 +12,11 @@ require "active_support/core_ext/string/inflections"
 module ActiveSupport
   # See ActiveSupport::Cache::Store for documentation.
   module Cache
-    autoload :FileStore,     "active_support/cache/file_store"
-    autoload :MemoryStore,   "active_support/cache/memory_store"
-    autoload :MemCacheStore, "active_support/cache/mem_cache_store"
-    autoload :NullStore,     "active_support/cache/null_store"
+    autoload :FileStore,        "active_support/cache/file_store"
+    autoload :MemoryStore,      "active_support/cache/memory_store"
+    autoload :MemCacheStore,    "active_support/cache/mem_cache_store"
+    autoload :NullStore,        "active_support/cache/null_store"
+    autoload :RedisCacheStore,  "active_support/cache/redis_cache_store"
 
     # These options mean something to all cache implementations. Individual cache
     # implementations may support additional options.
@@ -90,11 +91,16 @@ module ActiveSupport
       private
         def retrieve_cache_key(key)
           case
-          when key.respond_to?(:cache_key_with_version) then key.cache_key_with_version
-          when key.respond_to?(:cache_key)              then key.cache_key
-          when key.is_a?(Array)                         then key.map { |element| retrieve_cache_key(element) }.to_param
-          when key.respond_to?(:to_a)                   then retrieve_cache_key(key.to_a)
-          else                                               key.to_param
+          when key.respond_to?(:cache_key_with_version)
+            key.cache_key_with_version
+          when key.respond_to?(:cache_key)
+            key.cache_key
+          when key.is_a?(Hash)
+            key.sort_by { |k, _| k.to_s }.collect { |k, v| "#{k}=#{v}" }.to_param
+          when key.respond_to?(:to_a)
+            key.to_a.collect { |element| retrieve_cache_key(element) }.to_param
+          else
+            key.to_param
           end.to_s
         end
 
@@ -148,12 +154,11 @@ module ActiveSupport
     #   cache.namespace = -> { @last_mod_time }  # Set the namespace to a variable
     #   @last_mod_time = Time.now  # Invalidate the entire cache by changing namespace
     #
-    # Caches can also store values in a compressed format to save space and
-    # reduce time spent sending data. Since there is overhead, values must be
-    # large enough to warrant compression. To turn on compression either pass
-    # <tt>compress: true</tt> in the initializer or as an option to +fetch+
-    # or +write+. To specify the threshold at which to compress values, set the
-    # <tt>:compress_threshold</tt> option. The default threshold is 16K.
+    # Cached data larger than 1kB are compressed by default. To turn off
+    # compression, pass <tt>compress: false</tt> to the initializer or to
+    # individual +fetch+ or +write+ method calls. The 1kB compression
+    # threshold is configurable with the <tt>:compress_threshold</tt> option,
+    # specified in bytes.
     class Store
       cattr_accessor :logger, instance_writer: true
 
@@ -212,8 +217,7 @@ module ActiveSupport
       # ask whether you should force a cache write. Otherwise, it's clearer to
       # just call <tt>Cache#write</tt>.
       #
-      # Setting <tt>:compress</tt> will store a large cache entry set by the call
-      # in a compressed format.
+      # Setting <tt>compress: false</tt> disables compression of the cache entry.
       #
       # Setting <tt>:expires_in</tt> will set an expiration time on the cache.
       # All caches support auto-expiring content after a specified number of
@@ -562,34 +566,34 @@ module ActiveSupport
           end
         end
 
-        # Prefixes a key with the namespace. Namespace and key will be delimited
-        # with a colon.
-        def normalize_key(key, options)
-          key = expanded_key(key)
-          namespace = options[:namespace] if options
-          prefix = namespace.is_a?(Proc) ? namespace.call : namespace
-          key = "#{prefix}:#{key}" if prefix
-          key
+        # Expands and namespaces the cache key. May be overridden by
+        # cache stores to do additional normalization.
+        def normalize_key(key, options = nil)
+          namespace_key Cache.expand_cache_key(key), options
         end
 
-        # Expands key to be a consistent string value. Invokes +cache_key+ if
-        # object responds to +cache_key+. Otherwise, +to_param+ method will be
-        # called. If the key is a Hash, then keys will be sorted alphabetically.
-        def expanded_key(key)
-          return key.cache_key.to_s if key.respond_to?(:cache_key)
+        # Prefix the key with a namespace string:
+        #
+        #   namespace_key 'foo', namespace: 'cache'
+        #   # => 'cache:foo'
+        #
+        # With a namespace block:
+        #
+        #   namespace_key 'foo', namespace: -> { 'cache' }
+        #   # => 'cache:foo'
+        def namespace_key(key, options = nil)
+          options = merged_options(options)
+          namespace = options[:namespace]
 
-          case key
-          when Array
-            if key.size > 1
-              key = key.collect { |element| expanded_key(element) }
-            else
-              key = key.first
-            end
-          when Hash
-            key = key.sort_by { |k, _| k.to_s }.collect { |k, v| "#{k}=#{v}" }
+          if namespace.respond_to?(:call)
+            namespace = namespace.call
           end
 
-          key.to_param
+          if namespace
+            "#{namespace}:#{key}"
+          else
+            key
+          end
         end
 
         def normalize_version(key, options = nil)
@@ -658,7 +662,7 @@ module ActiveSupport
     class Entry # :nodoc:
       attr_reader :version
 
-      DEFAULT_COMPRESS_LIMIT = 16.kilobytes
+      DEFAULT_COMPRESS_LIMIT = 1.kilobyte
 
       # Creates a new cache entry for the specified value. Options supported are
       # +:compress+, +:compress_threshold+, and +:expires_in+.
@@ -733,8 +737,8 @@ module ActiveSupport
 
       private
         def should_compress?(value, options)
-          if value && options[:compress]
-            compress_threshold = options[:compress_threshold] || DEFAULT_COMPRESS_LIMIT
+          if value && options.fetch(:compress, true)
+            compress_threshold = options.fetch(:compress_threshold, DEFAULT_COMPRESS_LIMIT)
             serialized_value_size = (value.is_a?(String) ? value : Marshal.dump(value)).bytesize
 
             return true if serialized_value_size >= compress_threshold
diff --git a/activesupport/lib/active_support/cache/mem_cache_store.rb b/activesupport/lib/active_support/cache/mem_cache_store.rb
index 9242a334f2..50f072388d 100644
--- a/activesupport/lib/active_support/cache/mem_cache_store.rb
+++ b/activesupport/lib/active_support/cache/mem_cache_store.rb
@@ -122,7 +122,7 @@ module ActiveSupport
         options = merged_options(options)
         instrument(:increment, name, amount: amount) do
           rescue_error_with nil do
-            @data.incr(normalize_key(name, options), amount)
+            @data.incr(normalize_key(name, options), amount, options[:expires_in])
           end
         end
       end
@@ -135,7 +135,7 @@ module ActiveSupport
         options = merged_options(options)
         instrument(:decrement, name, amount: amount) do
           rescue_error_with nil do
-            @data.decr(normalize_key(name, options), amount)
+            @data.decr(normalize_key(name, options), amount, options[:expires_in])
           end
         end
       end
diff --git a/activesupport/lib/active_support/cache/redis_cache_store.rb b/activesupport/lib/active_support/cache/redis_cache_store.rb
new file mode 100644
index 0000000000..08200a556f
--- /dev/null
+++ b/activesupport/lib/active_support/cache/redis_cache_store.rb
@@ -0,0 +1,404 @@
+# frozen_string_literal: true
+
+begin
+  gem "redis", ">= 4.0.1"
+  require "redis"
+  require "redis/distributed"
+rescue LoadError
+  warn "The Redis cache store requires the redis gem, version 4.0.1 or later. Please add it to your Gemfile: `gem \"redis\", \"~> 4.0\"`"
+  raise
+end
+
+# Prefer the hiredis driver but don't require it.
+begin
+  require "redis/connection/hiredis"
+rescue LoadError
+end
+
+require "digest/sha2"
+require "active_support/core_ext/marshal"
+
+module ActiveSupport
+  module Cache
+    # Redis cache store.
+    #
+    # Deployment note: Take care to use a *dedicated Redis cache* rather
+    # than pointing this at your existing Redis server. It won't cope well
+    # with mixed usage patterns and it won't expire cache entries by default.
+    #
+    # Redis cache server setup guide: https://redis.io/topics/lru-cache
+    #
+    # * Supports vanilla Redis, hiredis, and Redis::Distributed.
+    # * Supports Memcached-like sharding across Redises with Redis::Distributed.
+    # * Fault tolerant. If the Redis server is unavailable, no exceptions are
+    #   raised. Cache fetches are all misses and writes are dropped.
+    # * Local cache. Hot in-memory primary cache within block/middleware scope.
+    # * `read_/write_multi` support for Redis mget/mset. Use Redis::Distributed
+    #   4.0.1+ for distributed mget support.
+    # * `delete_matched` support for Redis KEYS globs.
+    class RedisCacheStore < Store
+      # Keys are truncated with their own SHA2 digest if they exceed 1kB
+      MAX_KEY_BYTESIZE = 1024
+
+      DEFAULT_REDIS_OPTIONS = {
+        connect_timeout:    20,
+        read_timeout:       1,
+        write_timeout:      1,
+        reconnect_attempts: 0,
+      }
+
+      DEFAULT_ERROR_HANDLER = -> (method:, returning:, exception:) {
+        logger.error { "RedisCacheStore: #{method} failed, returned #{returning.inspect}: #{e.class}: #{e.message}" } if logger
+      }
+
+      DELETE_GLOB_LUA = "for i, name in ipairs(redis.call('KEYS', ARGV[1])) do redis.call('DEL', name); end"
+      private_constant :DELETE_GLOB_LUA
+
+      # Support raw values in the local cache strategy.
+      module LocalCacheWithRaw # :nodoc:
+        private
+          def read_entry(key, options)
+            entry = super
+            if options[:raw] && local_cache && entry
+              entry = deserialize_entry(entry.value)
+            end
+            entry
+          end
+
+          def write_entry(key, entry, options)
+            if options[:raw] && local_cache
+              raw_entry = Entry.new(entry.value.to_s)
+              raw_entry.expires_at = entry.expires_at
+              super(key, raw_entry, options)
+            else
+              super
+            end
+          end
+
+          def write_multi_entries(entries, options)
+            if options[:raw] && local_cache
+              raw_entries = entries.map do |key, entry|
+                raw_entry = Entry.new(entry.value.to_s)
+                raw_entry.expires_at = entry.expires_at
+              end.to_h
+
+              super(raw_entries, options)
+            else
+              super
+            end
+          end
+      end
+
+      prepend Strategy::LocalCache
+      prepend LocalCacheWithRaw
+
+      class << self
+        # Factory method to create a new Redis instance.
+        #
+        # Handles four options: :redis block, :redis instance, single :url
+        # string, and multiple :url strings.
+        #
+        #   Option  Class       Result
+        #   :redis  Proc    ->  options[:redis].call
+        #   :redis  Object  ->  options[:redis]
+        #   :url    String  ->  Redis.new(url: …)
+        #   :url    Array   ->  Redis::Distributed.new([{ url: … }, { url: … }, …])
+        #
+        def build_redis(redis: nil, url: nil, **redis_options) #:nodoc:
+          urls = Array(url)
+
+          if redis.respond_to?(:call)
+            redis.call
+          elsif redis
+            redis
+          elsif urls.size > 1
+            build_redis_distributed_client urls: urls, **redis_options
+          else
+            build_redis_client url: urls.first, **redis_options
+          end
+        end
+
+        private
+          def build_redis_distributed_client(urls:, **redis_options)
+            ::Redis::Distributed.new([], DEFAULT_REDIS_OPTIONS.merge(redis_options)).tap do |dist|
+              urls.each { |u| dist.add_node url: u }
+            end
+          end
+
+          def build_redis_client(url:, **redis_options)
+            ::Redis.new DEFAULT_REDIS_OPTIONS.merge(redis_options.merge(url: url))
+          end
+      end
+
+      attr_reader :redis_options
+      attr_reader :max_key_bytesize
+
+      # Creates a new Redis cache store.
+      #
+      # Handles three options: block provided to instantiate, single URL
+      # provided, and multiple URLs provided.
+      #
+      #   :redis Proc   -> options[:redis].call
+      #   :url   String -> Redis.new(url: …)
+      #   :url   Array  -> Redis::Distributed.new([{ url: … }, { url: … }, …])
+      #
+      # No namespace is set by default. Provide one if the Redis cache
+      # server is shared with other apps: `namespace: 'myapp-cache'`.
+      #
+      # Compression is enabled by default with a 1kB threshold, so cached
+      # values larger than 1kB are automatically compressed. Disable by
+      # passing `cache: false` or change the threshold by passing
+      # `compress_threshold: 4.kilobytes`.
+      #
+      # No expiry is set on cache entries by default. Redis is expected to
+      # be configured with an eviction policy that automatically deletes
+      # least-recently or -frequently used keys when it reaches max memory.
+      # See https://redis.io/topics/lru-cache for cache server setup.
+      #
+      # Race condition TTL is not set by default. This can be used to avoid
+      # "thundering herd" cache writes when hot cache entries are expired.
+      # See <tt>ActiveSupport::Cache::Store#fetch</tt> for more.
+      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
+        @redis_options = redis_options
+
+        @max_key_bytesize = MAX_KEY_BYTESIZE
+        @error_handler = error_handler
+
+        super namespace: namespace,
+          compress: compress, compress_threshold: compress_threshold,
+          expires_in: expires_in, race_condition_ttl: race_condition_ttl
+      end
+
+      def redis
+        @redis ||= self.class.build_redis(**redis_options)
+      end
+
+      def inspect
+        instance = @redis || @redis_options
+        "<##{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
+      end
+
+      # Cache Store API implementation.
+      #
+      # Read multiple values at once. Returns a hash of requested keys ->
+      # fetched values.
+      def read_multi(*names)
+        if mget_capable?
+          read_multi_mget(*names)
+        else
+          super
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Supports Redis KEYS glob patterns:
+      #
+      #   h?llo matches hello, hallo and hxllo
+      #   h*llo matches hllo and heeeello
+      #   h[ae]llo matches hello and hallo, but not hillo
+      #   h[^e]llo matches hallo, hbllo, ... but not hello
+      #   h[a-b]llo matches hallo and hbllo
+      #
+      # Use \ to escape special characters if you want to match them verbatim.
+      #
+      # See https://redis.io/commands/KEYS for more.
+      #
+      # Failsafe: Raises errors.
+      def delete_matched(matcher, options = nil)
+        instrument :delete_matched, matcher do
+          case matcher
+          when String
+            redis.eval DELETE_GLOB_LUA, [], [namespace_key(matcher, options)]
+          else
+            raise ArgumentError, "Only Redis glob strings are supported: #{matcher.inspect}"
+          end
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Increment a cached value. This method uses the Redis incr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      #
+      # Failsafe: Raises errors.
+      def increment(name, amount = 1, options = nil)
+        instrument :increment, name, amount: amount do
+          redis.incrby normalize_key(name, options), amount
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Decrement a cached value. This method uses the Redis decr atomic
+      # operator and can only be used on values written with the :raw option.
+      # Calling it on a value not stored with :raw will initialize that value
+      # to zero.
+      #
+      # Failsafe: Raises errors.
+      def decrement(name, amount = 1, options = nil)
+        instrument :decrement, name, amount: amount do
+          redis.decrby normalize_key(name, options), amount
+        end
+      end
+
+      # Cache Store API implementation.
+      #
+      # Removes expired entries. Handled natively by Redis least-recently-/
+      # least-frequently-used expiry, so manual cleanup is not supported.
+      def cleanup(options = nil)
+        super
+      end
+
+      # Clear the entire cache on all Redis servers. Safe to use on
+      # shared servers if the cache is namespaced.
+      #
+      # Failsafe: Raises errors.
+      def clear(options = nil)
+        failsafe :clear do
+          if namespace = merged_options(options)[namespace]
+            delete_matched "*", namespace: namespace
+          else
+            redis.flushdb
+          end
+        end
+      end
+
+      def mget_capable? #:nodoc:
+        set_redis_capabilities unless defined? @mget_capable
+        @mget_capable
+      end
+
+      def mset_capable? #:nodoc:
+        set_redis_capabilities unless defined? @mset_capable
+        @mset_capable
+      end
+
+      private
+        def set_redis_capabilities
+          case redis
+          when Redis::Distributed
+            @mget_capable = true
+            @mset_capable = false
+          else
+            @mget_capable = true
+            @mset_capable = true
+          end
+        end
+
+        # Store provider interface:
+        # Read an entry from the cache.
+        def read_entry(key, options = nil)
+          failsafe :read_entry do
+            deserialize_entry redis.get(key)
+          end
+        end
+
+        def read_multi_mget(*names)
+          options = names.extract_options!
+          options = merged_options(options)
+
+          keys = names.map { |name| normalize_key(name, options) }
+          values = redis.mget(*keys)
+
+          names.zip(values).each_with_object({}) do |(name, value), results|
+            if value
+              entry = deserialize_entry(value)
+              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
+                results[name] = entry.value
+              end
+            end
+          end
+        end
+
+        # Write an entry to the cache.
+        #
+        # Requires Redis 2.6.12+ for extended SET options.
+        def write_entry(key, entry, unless_exist: false, raw: false, expires_in: nil, race_condition_ttl: nil, **options)
+          value = raw ? entry.value.to_s : serialize_entry(entry)
+
+          # If race condition TTL is in use, ensure that cache entries
+          # stick around a bit longer after they would have expired
+          # so we can purposefully serve stale entries.
+          if race_condition_ttl && expires_in && expires_in > 0 && !raw
+            expires_in += 5.minutes
+          end
+
+          failsafe :write_entry do
+            if unless_exist || expires_in
+              modifiers = {}
+              modifiers[:nx] = unless_exist
+              modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
+
+              redis.set key, value, modifiers
+            else
+              redis.set key, value
+            end
+          end
+        end
+
+        # Delete an entry from the cache.
+        def delete_entry(key, options)
+          failsafe :delete_entry, returning: false do
+            redis.del key
+          end
+        end
+
+        # Nonstandard store provider API to write multiple values at once.
+        def write_multi_entries(entries, expires_in: nil, **options)
+          if entries.any?
+            if mset_capable? && expires_in.nil?
+              failsafe :write_multi_entries do
+                redis.mapped_mset(entries)
+              end
+            else
+              super
+            end
+          end
+        end
+
+        # Truncate keys that exceed 1kB.
+        def normalize_key(key, options)
+          truncate_key super
+        end
+
+        def truncate_key(key)
+          if key.bytesize > max_key_bytesize
+            suffix = ":sha2:#{Digest::SHA2.hexdigest(key)}"
+            truncate_at = max_key_bytesize - suffix.bytesize
+            "#{key.byteslice(0, truncate_at)}#{suffix}"
+          else
+            key
+          end
+        end
+
+        def deserialize_entry(raw_value)
+          if raw_value
+            entry = Marshal.load(raw_value) rescue raw_value
+            entry.is_a?(Entry) ? entry : Entry.new(entry)
+          end
+        end
+
+        def serialize_entry(entry)
+          Marshal.dump(entry)
+        end
+
+        def failsafe(method, returning: nil)
+          yield
+        rescue ::Redis::BaseConnectionError => e
+          handle_exception exception: e, method: method, returning: returning
+          returning
+        end
+
+        def handle_exception(exception:, method:, returning:)
+          if @error_handler
+            @error_handler.(method: method, exception: exception, returning: returning)
+          end
+        rescue => failsafe
+          warn "RedisCacheStore ignored exception in handle_exception: #{failsafe.class}: #{failsafe.message}\n  #{failsafe.backtrace.join("\n  ")}"
+        end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb b/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb
new file mode 100644
index 0000000000..a8455c0048
--- /dev/null
+++ b/activesupport/lib/active_support/concurrency/load_interlock_aware_monitor.rb
@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "monitor"
+
+module ActiveSupport
+  module Concurrency
+    # A monitor that will permit dependency loading while blocked waiting for
+    # the lock.
+    class LoadInterlockAwareMonitor < Monitor
+      # Enters an exclusive section, but allows dependency loading while blocked
+      def mon_enter
+        mon_try_enter ||
+          ActiveSupport::Dependencies.interlock.permit_concurrent_loads { super }
+      end
+    end
+  end
+end
diff --git a/activesupport/lib/active_support/deprecation/constant_accessor.rb b/activesupport/lib/active_support/deprecation/constant_accessor.rb
index 3d7eedf637..dd515cd6f4 100644
--- a/activesupport/lib/active_support/deprecation/constant_accessor.rb
+++ b/activesupport/lib/active_support/deprecation/constant_accessor.rb
@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/inflector/methods"
-
 module ActiveSupport
   class Deprecation
     # DeprecatedConstantAccessor transforms a constant into a deprecated one by
@@ -29,6 +27,8 @@ module ActiveSupport
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     module DeprecatedConstantAccessor
       def self.included(base)
+        require "active_support/inflector/methods"
+
         extension = Module.new do
           def const_missing(missing_const_name)
             if class_variable_defined?(:@@_deprecated_constants)
diff --git a/activesupport/lib/active_support/deprecation/proxy_wrappers.rb b/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
index f6c6648917..782ad2519c 100644
--- a/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
+++ b/activesupport/lib/active_support/deprecation/proxy_wrappers.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/inflector/methods"
 require "active_support/core_ext/regexp"
 
 module ActiveSupport
@@ -125,6 +124,8 @@ module ActiveSupport
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < DeprecationProxy
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
+        require "active_support/inflector/methods"
+
         @old_const = old_const
         @new_const = new_const
         @deprecator = deprecator
diff --git a/activesupport/lib/active_support/encrypted_configuration.rb b/activesupport/lib/active_support/encrypted_configuration.rb
index b403048627..c52d3869de 100644
--- a/activesupport/lib/active_support/encrypted_configuration.rb
+++ b/activesupport/lib/active_support/encrypted_configuration.rb
@@ -22,6 +22,12 @@ module ActiveSupport
       ""
     end
 
+    def write(contents)
+      deserialize(contents)
+
+      super
+    end
+
     def config
       @config ||= deserialize(read).deep_symbolize_keys
     end
@@ -36,7 +42,7 @@ module ActiveSupport
       end
 
       def deserialize(config)
-        config.present? ? YAML.load(config) : {}
+        config.present? ? YAML.load(config, content_path) : {}
       end
   end
 end
diff --git a/activesupport/lib/active_support/encrypted_file.rb b/activesupport/lib/active_support/encrypted_file.rb
index 1c4c1cb457..3d1455fb95 100644
--- a/activesupport/lib/active_support/encrypted_file.rb
+++ b/activesupport/lib/active_support/encrypted_file.rb
@@ -2,8 +2,6 @@
 
 require "pathname"
 require "active_support/message_encryptor"
-require "active_support/core_ext/string/strip"
-require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
   class EncryptedFile
diff --git a/activesupport/lib/active_support/inflector/inflections.rb b/activesupport/lib/active_support/inflector/inflections.rb
index a639eddf10..0450a4be4c 100644
--- a/activesupport/lib/active_support/inflector/inflections.rb
+++ b/activesupport/lib/active_support/inflector/inflections.rb
@@ -4,6 +4,7 @@ require "concurrent/map"
 require "active_support/core_ext/array/prepend_and_append"
 require "active_support/core_ext/regexp"
 require "active_support/i18n"
+require "active_support/deprecation"
 
 module ActiveSupport
   module Inflector
@@ -67,16 +68,21 @@ module ActiveSupport
       end
 
       attr_reader :plurals, :singulars, :uncountables, :humans, :acronyms, :acronym_regex
+      deprecate :acronym_regex
+
+      attr_reader :acronyms_camelize_regex, :acronyms_underscore_regex # :nodoc:
 
       def initialize
-        @plurals, @singulars, @uncountables, @humans, @acronyms, @acronym_regex = [], [], Uncountables.new, [], {}, /(?=a)b/
+        @plurals, @singulars, @uncountables, @humans, @acronyms = [], [], Uncountables.new, [], {}
+        define_acronym_regex_patterns
       end
 
       # Private, for the test suite.
       def initialize_dup(orig) # :nodoc:
-        %w(plurals singulars uncountables humans acronyms acronym_regex).each do |scope|
+        %w(plurals singulars uncountables humans acronyms).each do |scope|
           instance_variable_set("@#{scope}", orig.send(scope).dup)
         end
+        define_acronym_regex_patterns
       end
 
       # Specifies a new acronym. An acronym must be specified as it will appear
@@ -130,7 +136,7 @@ module ActiveSupport
       #   camelize 'mcdonald'   # => 'McDonald'
       def acronym(word)
         @acronyms[word.downcase] = word
-        @acronym_regex = /#{@acronyms.values.join("|")}/
+        define_acronym_regex_patterns
       end
 
       # Specifies a new pluralization rule and its replacement. The rule can
@@ -225,6 +231,14 @@ module ActiveSupport
           instance_variable_set "@#{scope}", []
         end
       end
+
+      private
+
+        def define_acronym_regex_patterns
+          @acronym_regex             = @acronyms.empty? ? /(?=a)b/ : /#{@acronyms.values.join("|")}/
+          @acronyms_camelize_regex   = /^(?:#{@acronym_regex}(?=\b|[A-Z_])|\w)/
+          @acronyms_underscore_regex = /(?:(?<=([A-Za-z\d]))|\b)(#{@acronym_regex})(?=\b|[^a-z])/
+        end
     end
 
     # Yields a singleton instance of Inflector::Inflections so you can specify
diff --git a/activesupport/lib/active_support/inflector/methods.rb b/activesupport/lib/active_support/inflector/methods.rb
index 3357b5eb32..60eeaa77cb 100644
--- a/activesupport/lib/active_support/inflector/methods.rb
+++ b/activesupport/lib/active_support/inflector/methods.rb
@@ -71,7 +71,7 @@ module ActiveSupport
       if uppercase_first_letter
         string = string.sub(/^[a-z\d]*/) { |match| inflections.acronyms[match] || match.capitalize }
       else
-        string = string.sub(/^(?:#{inflections.acronym_regex}(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
+        string = string.sub(inflections.acronyms_camelize_regex) { |match| match.downcase }
       end
       string.gsub!(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{inflections.acronyms[$2] || $2.capitalize}" }
       string.gsub!("/".freeze, "::".freeze)
@@ -92,7 +92,7 @@ module ActiveSupport
     def underscore(camel_cased_word)
       return camel_cased_word unless /[A-Z-]|::/.match?(camel_cased_word)
       word = camel_cased_word.to_s.gsub("::".freeze, "/".freeze)
-      word.gsub!(/(?:(?<=([A-Za-z\d]))|\b)(#{inflections.acronym_regex})(?=\b|[^a-z])/) { "#{$1 && '_'.freeze }#{$2.downcase}" }
+      word.gsub!(inflections.acronyms_underscore_regex) { "#{$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)
diff --git a/activesupport/lib/active_support/reloader.rb b/activesupport/lib/active_support/reloader.rb
index 6cd11b1a26..b26d9c3665 100644
--- a/activesupport/lib/active_support/reloader.rb
+++ b/activesupport/lib/active_support/reloader.rb
@@ -28,14 +28,17 @@ module ActiveSupport
 
     define_callbacks :class_unload
 
+    # Registers a callback that will run once at application startup and every time the code is reloaded.
     def self.to_prepare(*args, &block)
       set_callback(:prepare, *args, &block)
     end
 
+    # Registers a callback that will run immediately before the classes are unloaded.
     def self.before_class_unload(*args, &block)
       set_callback(:class_unload, *args, &block)
     end
 
+    # Registers a callback that will run immediately after the classes are unloaded.
     def self.after_class_unload(*args, &block)
       set_callback(:class_unload, :after, *args, &block)
     end
diff --git a/activesupport/lib/active_support/test_case.rb b/activesupport/lib/active_support/test_case.rb
index ee5286bd55..d1f7e6ea09 100644
--- a/activesupport/lib/active_support/test_case.rb
+++ b/activesupport/lib/active_support/test_case.rb
@@ -11,7 +11,6 @@ require "active_support/testing/isolation"
 require "active_support/testing/constant_lookup"
 require "active_support/testing/time_helpers"
 require "active_support/testing/file_fixtures"
-require "active_support/core_ext/kernel/reporting"
 
 module ActiveSupport
   class TestCase < ::Minitest::Test
diff --git a/activesupport/lib/active_support/values/time_zone.rb b/activesupport/lib/active_support/values/time_zone.rb
index 4d1fbd4453..b294d99fe0 100644
--- a/activesupport/lib/active_support/values/time_zone.rb
+++ b/activesupport/lib/active_support/values/time_zone.rb
@@ -30,7 +30,7 @@ module ActiveSupport
   class TimeZone
     # Keys are Rails TimeZone names, values are TZInfo identifiers.
     MAPPING = {
-      "International Date Line West" => "Pacific/Midway",
+      "International Date Line West" => "Etc/GMT+12",
       "Midway Island"                => "Pacific/Midway",
       "American Samoa"               => "Pacific/Pago_Pago",
       "Hawaii"                       => "Pacific/Honolulu",
@@ -506,7 +506,7 @@ module ActiveSupport
     # Available so that TimeZone instances respond like TZInfo::Timezone
     # instances.
     def period_for_local(time, dst = true)
-      tzinfo.period_for_local(time, dst)
+      tzinfo.period_for_local(time, dst) { |periods| periods.last }
     end
 
     def periods_for_local(time) #:nodoc:
diff --git a/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
index 2fa2d7af88..16b7abc679 100644
--- a/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
+++ b/activesupport/test/cache/behaviors/cache_increment_decrement_behavior.rb
@@ -8,7 +8,9 @@ module CacheIncrementDecrementBehavior
     assert_equal 2, @cache.read("foo").to_i
     assert_equal 3, @cache.increment("foo")
     assert_equal 3, @cache.read("foo").to_i
-    assert_nil @cache.increment("bar")
+
+    missing = @cache.increment("bar")
+    assert(missing.nil? || missing == 1)
   end
 
   def test_decrement
@@ -18,6 +20,8 @@ module CacheIncrementDecrementBehavior
     assert_equal 2, @cache.read("foo").to_i
     assert_equal 1, @cache.decrement("foo")
     assert_equal 1, @cache.read("foo").to_i
-    assert_nil @cache.decrement("bar")
+
+    missing = @cache.decrement("bar")
+    assert(missing.nil? || missing == -1)
   end
 end
diff --git a/activesupport/test/cache/behaviors/cache_store_behavior.rb b/activesupport/test/cache/behaviors/cache_store_behavior.rb
index 582e902f72..73a9b2a71c 100644
--- a/activesupport/test/cache/behaviors/cache_store_behavior.rb
+++ b/activesupport/test/cache/behaviors/cache_store_behavior.rb
@@ -146,6 +146,16 @@ module CacheStoreBehavior
     assert_nil @cache.read("foo")
   end
 
+  def test_read_and_write_uncompressed_small_data
+    @cache.write("foo", "bar", compress: false)
+    assert_equal "bar", @cache.read("foo")
+  end
+
+  def test_read_and_write_uncompressed_nil
+    @cache.write("foo", nil, compress: false)
+    assert_nil @cache.read("foo")
+  end
+
   def test_cache_key
     obj = Object.new
     def obj.cache_key
diff --git a/activesupport/test/cache/behaviors/local_cache_behavior.rb b/activesupport/test/cache/behaviors/local_cache_behavior.rb
index 8dec8090b1..f7302df4c8 100644
--- a/activesupport/test/cache/behaviors/local_cache_behavior.rb
+++ b/activesupport/test/cache/behaviors/local_cache_behavior.rb
@@ -20,7 +20,11 @@ module LocalCacheBehavior
   end
 
   def test_cleanup_clears_local_cache_but_not_remote_cache
-    skip unless @cache.class.instance_methods(false).include?(:cleanup)
+    begin
+      @cache.cleanup
+    rescue NotImplementedError
+      skip
+    end
 
     @cache.with_local_cache do
       @cache.write("foo", "bar")
diff --git a/activesupport/test/cache/cache_entry_test.rb b/activesupport/test/cache/cache_entry_test.rb
index 51b214ad8f..80ff7ad564 100644
--- a/activesupport/test/cache/cache_entry_test.rb
+++ b/activesupport/test/cache/cache_entry_test.rb
@@ -14,16 +14,23 @@ class CacheEntryTest < ActiveSupport::TestCase
     end
   end
 
-  def test_compress_values
+  def test_compressed_values
     value = "value" * 100
     entry = ActiveSupport::Cache::Entry.new(value, compress: true, compress_threshold: 1)
     assert_equal value, entry.value
     assert(value.bytesize > entry.size, "value is compressed")
   end
 
-  def test_non_compress_values
+  def test_compressed_by_default
     value = "value" * 100
-    entry = ActiveSupport::Cache::Entry.new(value)
+    entry = ActiveSupport::Cache::Entry.new(value, compress_threshold: 1)
+    assert_equal value, entry.value
+    assert(value.bytesize > entry.size, "value is compressed")
+  end
+
+  def test_uncompressed_values
+    value = "value" * 100
+    entry = ActiveSupport::Cache::Entry.new(value, compress: false)
     assert_equal value, entry.value
     assert_equal value.bytesize, entry.size
   end
diff --git a/activesupport/test/cache/stores/mem_cache_store_test.rb b/activesupport/test/cache/stores/mem_cache_store_test.rb
index 1b73fb65eb..99624caf8a 100644
--- a/activesupport/test/cache/stores/mem_cache_store_test.rb
+++ b/activesupport/test/cache/stores/mem_cache_store_test.rb
@@ -57,6 +57,22 @@ class MemCacheStoreTest < ActiveSupport::TestCase
     end
   end
 
+  def test_increment_expires_in
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    assert_called_with cache.instance_variable_get(:@data), :incr, [ "foo", 1, 60 ] do
+      cache.increment("foo", 1, expires_in: 60)
+    end
+  end
+
+  def test_decrement_expires_in
+    cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
+    cache.clear
+    assert_called_with cache.instance_variable_get(:@data), :decr, [ "foo", 1, 60 ] do
+      cache.decrement("foo", 1, expires_in: 60)
+    end
+  end
+
   def test_local_cache_raw_values_with_marshal
     cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, raw: true)
     cache.clear
diff --git a/activesupport/test/cache/stores/redis_cache_store_test.rb b/activesupport/test/cache/stores/redis_cache_store_test.rb
new file mode 100644
index 0000000000..988de9207f
--- /dev/null
+++ b/activesupport/test/cache/stores/redis_cache_store_test.rb
@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "active_support/cache"
+require "active_support/cache/redis_cache_store"
+require_relative "../behaviors"
+
+module ActiveSupport::Cache::RedisCacheStoreTests
+  class LookupTest < ActiveSupport::TestCase
+    test "may be looked up as :redis_cache_store" do
+      assert_kind_of ActiveSupport::Cache::RedisCacheStore,
+        ActiveSupport::Cache.lookup_store(:redis_cache_store)
+    end
+  end
+
+  class InitializationTest < ActiveSupport::TestCase
+    test "omitted URL uses Redis client with default settings" do
+      assert_called_with Redis, :new, [
+        url: nil,
+        connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+        reconnect_attempts: 0,
+      ] do
+        build
+      end
+    end
+
+    test "no URLs uses Redis client with default settings" do
+      assert_called_with Redis, :new, [
+        url: nil,
+        connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+        reconnect_attempts: 0,
+      ] do
+        build url: []
+      end
+    end
+
+    test "singular URL uses Redis client" do
+      assert_called_with Redis, :new, [
+        url: "redis://localhost:6379/0",
+        connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+        reconnect_attempts: 0,
+      ] do
+        build url: "redis://localhost:6379/0"
+      end
+    end
+
+    test "one URL uses Redis client" do
+      assert_called_with Redis, :new, [
+        url: "redis://localhost:6379/0",
+        connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+        reconnect_attempts: 0,
+      ] do
+        build url: %w[ redis://localhost:6379/0 ]
+      end
+    end
+
+    test "multiple URLs uses Redis::Distributed client" do
+      assert_called_with Redis, :new, [
+        [ url: "redis://localhost:6379/0",
+          connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+          reconnect_attempts: 0 ],
+        [ url: "redis://localhost:6379/1",
+          connect_timeout: 20, read_timeout: 1, write_timeout: 1,
+          reconnect_attempts: 0 ],
+      ], returns: Redis.new do
+        @cache = build url: %w[ redis://localhost:6379/0 redis://localhost:6379/1 ]
+        assert_kind_of ::Redis::Distributed, @cache.redis
+      end
+    end
+
+    test "block argument uses yielded client" do
+      block = -> { :custom_redis_client }
+      assert_called block, :call do
+        build redis: block
+      end
+    end
+
+    private
+      def build(**kwargs)
+        ActiveSupport::Cache::RedisCacheStore.new(**kwargs).tap do |cache|
+          cache.redis
+        end
+      end
+  end
+
+  class StoreTest < ActiveSupport::TestCase
+    setup do
+      @namespace = "namespace"
+
+      @cache = ActiveSupport::Cache::RedisCacheStore.new(timeout: 0.1, namespace: @namespace, expires_in: 60)
+      #@cache.logger = Logger.new($stdout)  # For test debugging
+
+      # For LocalCacheBehavior tests
+      @peek = ActiveSupport::Cache::RedisCacheStore.new(timeout: 0.1, namespace: @namespace)
+    end
+
+    teardown do
+      @cache.clear
+      @cache.redis.disconnect!
+    end
+  end
+
+  class RedisCacheStoreCommonBehaviorTest < StoreTest
+    include CacheStoreBehavior
+    include CacheStoreVersionBehavior
+    include LocalCacheBehavior
+    include CacheIncrementDecrementBehavior
+    include AutoloadingCacheBehavior
+  end
+
+  # Separate test class so we can omit the namespace which causes expected,
+  # appropriate complaints about incompatible string encodings.
+  class KeyEncodingSafetyTest < StoreTest
+    include EncodedKeyCacheBehavior
+
+    setup do
+      @cache = ActiveSupport::Cache::RedisCacheStore.new(timeout: 0.1)
+      @cache.logger = nil
+    end
+  end
+
+  class StoreAPITest < StoreTest
+  end
+
+  class FailureSafetyTest < StoreTest
+    test "fetch read failure returns nil" do
+    end
+
+    test "fetch read failure does not attempt to write" do
+    end
+
+    test "write failure returns nil" do
+    end
+  end
+
+  class DeleteMatchedTest < StoreTest
+    test "deletes keys matching glob" do
+      @cache.write("foo", "bar")
+      @cache.write("fu", "baz")
+      @cache.delete_matched("foo*")
+      assert !@cache.exist?("foo")
+      assert @cache.exist?("fu")
+    end
+
+    test "fails with regexp matchers" do
+      assert_raise ArgumentError do
+        @cache.delete_matched(/OO/i)
+      end
+    end
+  end
+end
diff --git a/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb b/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb
new file mode 100644
index 0000000000..2d0f45ec5f
--- /dev/null
+++ b/activesupport/test/concurrency/load_interlock_aware_monitor_test.rb
@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "abstract_unit"
+require "concurrent/atomic/count_down_latch"
+require "active_support/concurrency/load_interlock_aware_monitor"
+
+module ActiveSupport
+  module Concurrency
+    class LoadInterlockAwareMonitorTest < ActiveSupport::TestCase
+      def setup
+        @monitor = ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+      end
+
+      def test_entering_with_no_blocking
+        assert @monitor.mon_enter
+      end
+
+      def test_entering_with_blocking
+        load_interlock_latch = Concurrent::CountDownLatch.new
+        monitor_latch = Concurrent::CountDownLatch.new
+
+        able_to_use_monitor = false
+        able_to_load = false
+
+        thread_with_load_interlock = Thread.new do
+          ActiveSupport::Dependencies.interlock.running do
+            load_interlock_latch.count_down
+            monitor_latch.wait
+
+            @monitor.synchronize do
+              able_to_use_monitor = true
+            end
+          end
+        end
+
+        thread_with_monitor_lock = Thread.new do
+          @monitor.synchronize do
+            monitor_latch.count_down
+            load_interlock_latch.wait
+
+            ActiveSupport::Dependencies.interlock.loading do
+              able_to_load = true
+            end
+          end
+        end
+
+        thread_with_load_interlock.join
+        thread_with_monitor_lock.join
+
+        assert able_to_use_monitor
+        assert able_to_load
+      end
+    end
+  end
+end
diff --git a/activesupport/test/core_ext/load_error_test.rb b/activesupport/test/core_ext/load_error_test.rb
index 4fdd228ff8..41b11d0c33 100644
--- a/activesupport/test/core_ext/load_error_test.rb
+++ b/activesupport/test/core_ext/load_error_test.rb
@@ -5,7 +5,7 @@ require "active_support/core_ext/load_error"
 
 class TestLoadError < ActiveSupport::TestCase
   def test_with_require
-    assert_raise(LoadError) { require 'no_this_file_don\'t_exist' }
+    assert_raise(LoadError) { require "no_this_file_don't_exist" }
   end
   def test_with_load
     assert_raise(LoadError) { load "nor_does_this_one" }
diff --git a/activesupport/test/core_ext/object/instance_variables_test.rb b/activesupport/test/core_ext/object/instance_variables_test.rb
index b9ec827954..a3d8daab5b 100644
--- a/activesupport/test/core_ext/object/instance_variables_test.rb
+++ b/activesupport/test/core_ext/object/instance_variables_test.rb
@@ -19,7 +19,7 @@ class ObjectInstanceVariableTest < ActiveSupport::TestCase
   end
 
   def test_instance_exec_passes_arguments_to_block
-    assert_equal %w(hello goodbye), "hello".instance_exec("goodbye") { |v| [self, v] }
+    assert_equal %w(hello goodbye), "hello".dup.instance_exec("goodbye") { |v| [self, v] }
   end
 
   def test_instance_exec_with_frozen_obj
@@ -27,7 +27,7 @@ class ObjectInstanceVariableTest < ActiveSupport::TestCase
   end
 
   def test_instance_exec_nested
-    assert_equal %w(goodbye olleh bar), "hello".instance_exec("goodbye") { |arg|
+    assert_equal %w(goodbye olleh bar), "hello".dup.instance_exec("goodbye") { |arg|
       [arg] + instance_exec("bar") { |v| [reverse, v] } }
   end
 end
diff --git a/activesupport/test/core_ext/string_ext_test.rb b/activesupport/test/core_ext/string_ext_test.rb
index 9fd6d8ac0f..5c5abe9fd1 100644
--- a/activesupport/test/core_ext/string_ext_test.rb
+++ b/activesupport/test/core_ext/string_ext_test.rb
@@ -197,7 +197,7 @@ class StringInflectionsTest < ActiveSupport::TestCase
   end
 
   def test_string_parameterized_underscore_preserve_case
-    StringToParameterizePreserceCaseWithUnderscore.each do |normal, slugged|
+    StringToParameterizePreserveCaseWithUnderscore.each do |normal, slugged|
       assert_equal(slugged, normal.parameterize(separator: "_", preserve_case: true))
     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 0f80a24758..ab96568956 100644
--- a/activesupport/test/core_ext/time_with_zone_test.rb
+++ b/activesupport/test/core_ext/time_with_zone_test.rb
@@ -50,6 +50,12 @@ class TimeWithZoneTest < ActiveSupport::TestCase
     assert_raise(ArgumentError) { @twz.in_time_zone(Object.new) }
   end
 
+  def test_in_time_zone_with_ambiguous_time
+    with_env_tz "Europe/Moscow" do
+      assert_equal Time.utc(2014, 10, 25, 22, 0, 0), Time.local(2014, 10, 26, 1, 0, 0).in_time_zone("Moscow")
+    end
+  end
+
   def test_localtime
     assert_equal @twz.localtime, @twz.utc.getlocal
     assert_instance_of Time, @twz.localtime
@@ -1301,4 +1307,10 @@ class TimeWithZoneMethodsForString < ActiveSupport::TestCase
     assert_raise(ArgumentError) { @u.in_time_zone(Object.new) }
     assert_raise(ArgumentError) { @z.in_time_zone(Object.new) }
   end
+
+  def test_in_time_zone_with_ambiguous_time
+    with_tz_default "Moscow" do
+      assert_equal Time.utc(2014, 10, 25, 22, 0, 0), "2014-10-26 01:00:00".in_time_zone
+    end
+  end
 end
diff --git a/activesupport/test/encrypted_configuration_test.rb b/activesupport/test/encrypted_configuration_test.rb
index 471faa8c12..0bc915be82 100644
--- a/activesupport/test/encrypted_configuration_test.rb
+++ b/activesupport/test/encrypted_configuration_test.rb
@@ -51,6 +51,14 @@ class EncryptedConfigurationTest < ActiveSupport::TestCase
     assert_equal "things", @credentials[:new]
   end
 
+  test "raise error when writing an invalid format value" do
+    assert_raise(Psych::SyntaxError) do
+      @credentials.change do |config_file|
+        config_file.write "login: *login\n  username: dummy"
+      end
+    end
+  end
+
   test "raises key error when accessing config via bang method" do
     assert_raise(KeyError) { @credentials.something! }
   end
diff --git a/activesupport/test/inflector_test.rb b/activesupport/test/inflector_test.rb
index 6cc1039d8e..0e3e576a70 100644
--- a/activesupport/test/inflector_test.rb
+++ b/activesupport/test/inflector_test.rb
@@ -224,6 +224,12 @@ class InflectorTest < ActiveSupport::TestCase
     assert_equal("json_html_api", ActiveSupport::Inflector.underscore("JSONHTMLAPI"))
   end
 
+  def test_acronym_regexp_is_deprecated
+    assert_deprecated do
+      ActiveSupport::Inflector.inflections.acronym_regex
+    end
+  end
+
   def test_underscore
     CamelToUnderscore.each do |camel, underscore|
       assert_equal(underscore, ActiveSupport::Inflector.underscore(camel))
diff --git a/activesupport/test/inflector_test_cases.rb b/activesupport/test/inflector_test_cases.rb
index f1214671ce..689370cccf 100644
--- a/activesupport/test/inflector_test_cases.rb
+++ b/activesupport/test/inflector_test_cases.rb
@@ -221,7 +221,7 @@ module InflectorTestCases
     "Test with malformed utf8 \251"       => "test_with_malformed_utf8"
   }
 
-  StringToParameterizePreserceCaseWithUnderscore = {
+  StringToParameterizePreserveCaseWithUnderscore = {
     "Donald E. Knuth"                     => "Donald_E_Knuth",
     "Random text with *(bad)* characters" => "Random_text_with_bad_characters",
     "With-some-dashes"                    => "With-some-dashes",
diff --git a/activesupport/test/time_zone_test.rb b/activesupport/test/time_zone_test.rb
index acb0ecd226..862e872494 100644
--- a/activesupport/test/time_zone_test.rb
+++ b/activesupport/test/time_zone_test.rb
@@ -32,6 +32,12 @@ class TimeZoneTest < ActiveSupport::TestCase
     end
   end
 
+  def test_period_for_local_with_ambigiuous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    period = zone.period_for_local(Time.utc(2015, 1, 1))
+    assert_equal period, zone.period_for_local(Time.utc(2014, 10, 26, 1, 0, 0))
+  end
+
   def test_from_integer_to_map
     assert_instance_of ActiveSupport::TimeZone, ActiveSupport::TimeZone[-28800] # PST
   end
@@ -195,6 +201,11 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_equal "EDT", twz.zone
   end
 
+  def test_local_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.local(2014, 10, 26, 1, 0, 0)
+  end
+
   def test_at
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     secs = 946684800.0
@@ -303,6 +314,11 @@ class TimeZoneTest < ActiveSupport::TestCase
     end
   end
 
+  def test_iso8601_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.parse("2014-10-26T01:00:00")
+  end
+
   def test_parse
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     twz = zone.parse("1999-12-31 19:00:00")
@@ -412,6 +428,11 @@ class TimeZoneTest < ActiveSupport::TestCase
     assert_equal "argument out of range", exception.message
   end
 
+  def test_parse_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.parse("2014-10-26 01:00:00")
+  end
+
   def test_rfc3339
     zone = ActiveSupport::TimeZone["Eastern Time (US & Canada)"]
     twz = zone.rfc3339("1999-12-31T14:00:00-10:00")
@@ -604,6 +625,11 @@ class TimeZoneTest < ActiveSupport::TestCase
     end
   end
 
+  def test_strptime_with_ambiguous_time
+    zone = ActiveSupport::TimeZone["Moscow"]
+    assert_equal Time.utc(2014, 10, 25, 22, 0, 0), zone.strptime("2014-10-26 01:00:00", "%Y-%m-%d %H:%M:%S")
+  end
+
   def test_utc_offset_lazy_loaded_from_tzinfo_when_not_passed_in_to_initialize
     tzinfo = TZInfo::Timezone.get("America/New_York")
     zone = ActiveSupport::TimeZone.create(tzinfo.name, nil, tzinfo)