activesupport 6.0.3 → 6.1.0.rc1

data/lib/active_support/cache/memory_store.rb

@@ -18,11 +18,27 @@ module ActiveSupport
     #
     # MemoryStore is thread-safe.
     class MemoryStore < Store
+      module DupCoder # :nodoc:
+        class << self
+          def load(entry)
+            entry = entry.dup
+            entry.dup_value!
+            entry
+          end
+
+          def dump(entry)
+            entry.dup_value!
+            entry
+          end
+        end
+      end
+
+      DEFAULT_CODER = DupCoder
+
       def initialize(options = nil)
         options ||= {}
         super(options)
         @data = {}
-        @key_access = {}
         @max_size = options[:size] || 32.megabytes
         @max_prune_time = options[:max_prune_time] || 2
         @cache_size = 0
@@ -39,7 +55,6 @@ module ActiveSupport
       def clear(options = nil)
         synchronize do
           @data.clear
-          @key_access.clear
           @cache_size = 0
         end
       end
@@ -65,7 +80,7 @@ module ActiveSupport
           start_time = Concurrent.monotonic_time
           cleanup
           instrument(:prune, target_size, from: @cache_size) do
-            keys = synchronize { @key_access.keys.sort { |a, b| @key_access[a].to_f <=> @key_access[b].to_f } }
+            keys = synchronize { @data.keys }
             keys.each do |key|
               delete_entry(key, **options)
               return if @cache_size <= target_size || (max_time && Concurrent.monotonic_time - start_time > max_time)
@@ -104,7 +119,7 @@ module ActiveSupport
       end
 
       def inspect # :nodoc:
-        "<##{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
+        "#<#{self.class.name} entries=#{@data.size}, size=#{@cache_size}, options=#{@options.inspect}>"
       end
 
       # Synchronize calls to the cache. This should be called wherever the underlying cache implementation
@@ -116,36 +131,34 @@ module ActiveSupport
       private
         PER_ENTRY_OVERHEAD = 240
 
-        def cached_size(key, entry)
-          key.to_s.bytesize + entry.size + PER_ENTRY_OVERHEAD
+        def cached_size(key, payload)
+          key.to_s.bytesize + payload.bytesize + PER_ENTRY_OVERHEAD
         end
 
         def read_entry(key, **options)
-          entry = @data[key]
+          entry = nil
           synchronize do
-            if entry
-              entry = entry.dup
-              entry.dup_value!
-              @key_access[key] = Time.now.to_f
-            else
-              @key_access.delete(key)
+            payload = @data.delete(key)
+            if payload
+              @data[key] = payload
+              entry = deserialize_entry(payload)
             end
           end
           entry
         end
 
         def write_entry(key, entry, **options)
-          entry.dup_value!
+          payload = serialize_entry(entry)
           synchronize do
-            old_entry = @data[key]
-            return false if @data.key?(key) && options[:unless_exist]
-            if old_entry
-              @cache_size -= (old_entry.size - entry.size)
+            return false if options[:unless_exist] && @data.key?(key)
+
+            old_payload = @data[key]
+            if old_payload
+              @cache_size -= (old_payload.bytesize - payload.bytesize)
             else
-              @cache_size += cached_size(key, entry)
+              @cache_size += cached_size(key, payload)
             end
-            @key_access[key] = Time.now.to_f
-            @data[key] = entry
+            @data[key] = payload
             prune(@max_size * 0.75, @max_prune_time) if @cache_size > @max_size
             true
           end
@@ -153,16 +166,15 @@ module ActiveSupport
 
         def delete_entry(key, **options)
           synchronize do
-            @key_access.delete(key)
-            entry = @data.delete(key)
-            @cache_size -= cached_size(key, entry) if entry
-            !!entry
+            payload = @data.delete(key)
+            @cache_size -= cached_size(key, payload) if payload
+            !!payload
           end
         end
 
         def modify_value(name, amount, options)
+          options = merged_options(options)
           synchronize do
-            options = merged_options(options)
             if num = read(name, options)
               num = num.to_i + amount
               write(name, num, options)

data/lib/active_support/cache/redis_cache_store.rb

@@ -74,14 +74,6 @@ module ActiveSupport
       # 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(serialize_entry(entry, raw: true))
@@ -177,7 +169,7 @@ module ActiveSupport
       # 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)
+      def initialize(namespace: nil, compress: true, compress_threshold: 1.kilobyte, coder: DEFAULT_CODER, expires_in: nil, race_condition_ttl: nil, error_handler: DEFAULT_ERROR_HANDLER, **redis_options)
         @redis_options = redis_options
 
         @max_key_bytesize = MAX_KEY_BYTESIZE
@@ -185,7 +177,8 @@ module ActiveSupport
 
         super namespace: namespace,
           compress: compress, compress_threshold: compress_threshold,
-          expires_in: expires_in, race_condition_ttl: race_condition_ttl
+          expires_in: expires_in, race_condition_ttl: race_condition_ttl,
+          coder: coder
       end
 
       def redis
@@ -203,7 +196,7 @@ module ActiveSupport
 
       def inspect
         instance = @redis || @redis_options
-        "<##{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
+        "#<#{self.class} options=#{options.inspect} redis=#{instance.inspect}>"
       end
 
       # Cache Store API implementation.
@@ -246,10 +239,14 @@ module ActiveSupport
             pattern = namespace_key(matcher, options)
             cursor = "0"
             # Fetch keys in batches using SCAN to avoid blocking the Redis server.
-            begin
-              cursor, keys = c.scan(cursor, match: pattern, count: SCAN_BATCH_SIZE)
-              c.del(*keys) unless keys.empty?
-            end until cursor == "0"
+            nodes = c.respond_to?(:nodes) ? c.nodes : [c]
+
+            nodes.each do |node|
+              begin
+                cursor, keys = node.scan(cursor, match: pattern, count: SCAN_BATCH_SIZE)
+                node.del(*keys) unless keys.empty?
+              end until cursor == "0"
+            end
           end
         end
       end
@@ -348,13 +345,14 @@ module ActiveSupport
         # Read an entry from the cache.
         def read_entry(key, **options)
           failsafe :read_entry do
-            deserialize_entry redis.with { |c| c.get(key) }
+            raw = options&.fetch(:raw, false)
+            deserialize_entry(redis.with { |c| c.get(key) }, raw: raw)
           end
         end
 
         def read_multi_entries(names, **options)
           if mget_capable?
-            read_multi_mget(*names)
+            read_multi_mget(*names, **options)
           else
             super
           end
@@ -364,6 +362,7 @@ module ActiveSupport
           options = names.extract_options!
           options = merged_options(options)
           return {} if names == []
+          raw = options&.fetch(:raw, false)
 
           keys = names.map { |name| normalize_key(name, options) }
 
@@ -373,7 +372,7 @@ module ActiveSupport
 
           names.zip(values).each_with_object({}) do |(name, value), results|
             if value
-              entry = deserialize_entry(value)
+              entry = deserialize_entry(value, raw: raw)
               unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(name, options))
                 results[name] = entry.value
               end
@@ -400,7 +399,7 @@ module ActiveSupport
               modifiers[:nx] = unless_exist
               modifiers[:px] = (1000 * expires_in.to_f).ceil if expires_in
 
-              redis.with { |c| c.set key, serialized_entry, modifiers }
+              redis.with { |c| c.set key, serialized_entry, **modifiers }
             else
               redis.with { |c| c.set key, serialized_entry }
             end
@@ -420,6 +419,11 @@ module ActiveSupport
           end
         end
 
+        # Deletes multiple entries in the cache. Returns the number of entries deleted.
+        def delete_multi_entries(entries, **_options)
+          redis.with { |c| c.del(entries) }
+        end
+
         # Nonstandard store provider API to write multiple values at once.
         def write_multi_entries(entries, expires_in: nil, **options)
           if entries.any?
@@ -435,11 +439,11 @@ module ActiveSupport
 
         # Truncate keys that exceed 1kB.
         def normalize_key(key, options)
-          truncate_key super.b
+          truncate_key super&.b
         end
 
         def truncate_key(key)
-          if key.bytesize > max_key_bytesize
+          if key && key.bytesize > max_key_bytesize
             suffix = ":sha2:#{::Digest::SHA2.hexdigest(key)}"
             truncate_at = max_key_bytesize - suffix.bytesize
             "#{key.byteslice(0, truncate_at)}#{suffix}"
@@ -448,10 +452,11 @@ module ActiveSupport
           end
         end
 
-        def deserialize_entry(serialized_entry)
-          if serialized_entry
-            entry = Marshal.load(serialized_entry) rescue serialized_entry
-            entry.is_a?(Entry) ? entry : Entry.new(entry)
+        def deserialize_entry(payload, raw:)
+          if payload && raw
+            Entry.new(payload, compress: false)
+          else
+            super(payload)
           end
         end
 
@@ -459,7 +464,7 @@ module ActiveSupport
           if raw
             entry.value.to_s
           else
-            Marshal.dump(entry)
+            super(entry)
           end
         end
 

data/lib/active_support/cache/strategy/local_cache.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/duplicable"
 require "active_support/core_ext/string/inflections"
 require "active_support/per_thread_registry"
 
@@ -65,8 +64,9 @@ module ActiveSupport
             values
           end
 
-          def write_entry(key, value, **options)
-            @data[key] = value
+          def write_entry(key, entry, **options)
+            entry.dup_value!
+            @data[key] = entry
             true
           end
 
@@ -75,7 +75,10 @@ module ActiveSupport
           end
 
           def fetch_entry(key, options = nil) # :nodoc:
-            @data.fetch(key) { @data[key] = yield }
+            entry = @data.fetch(key) { @data[key] = yield }
+            dup_entry = entry.dup
+            dup_entry&.dup_value!
+            dup_entry
           end
         end
 
@@ -104,6 +107,12 @@ module ActiveSupport
           super
         end
 
+        def delete_matched(matcher, options = nil) # :nodoc:
+          return super unless cache = local_cache
+          cache.clear
+          super
+        end
+
         def increment(name, amount = 1, **options) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
@@ -160,7 +169,7 @@ module ActiveSupport
             cache = local_cache
             cache.mute do
               if value
-                cache.write(name, value, **options)
+                cache.write(name, value, options)
               else
                 cache.delete(name, **options)
               end

data/lib/active_support/callbacks.rb

@@ -4,10 +4,7 @@ require "active_support/concern"
 require "active_support/descendants_tracker"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/class/attribute"
-require "active_support/core_ext/kernel/reporting"
-require "active_support/core_ext/kernel/singleton_class"
 require "active_support/core_ext/string/filters"
-require "active_support/deprecation"
 require "thread"
 
 module ActiveSupport
@@ -103,32 +100,6 @@ module ActiveSupport
         env = Filters::Environment.new(self, false, nil)
         next_sequence = callbacks.compile
 
-        invoke_sequence = Proc.new do
-          skipped = nil
-          while true
-            current = next_sequence
-            current.invoke_before(env)
-            if current.final?
-              env.value = !env.halted && (!block_given? || yield)
-            elsif current.skip?(env)
-              (skipped ||= []) << current
-              next_sequence = next_sequence.nested
-              next
-            else
-              next_sequence = next_sequence.nested
-              begin
-                target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
-                target.send(method, *arguments, &block)
-              ensure
-                next_sequence = current
-              end
-            end
-            current.invoke_after(env)
-            skipped.pop.invoke_after(env) while skipped && skipped.first
-            break env.value
-          end
-        end
-
         # Common case: no 'around' callbacks defined
         if next_sequence.final?
           next_sequence.invoke_before(env)
@@ -136,6 +107,33 @@ module ActiveSupport
           next_sequence.invoke_after(env)
           env.value
         else
+          invoke_sequence = Proc.new do
+            skipped = nil
+
+            while true
+              current = next_sequence
+              current.invoke_before(env)
+              if current.final?
+                env.value = !env.halted && (!block_given? || yield)
+              elsif current.skip?(env)
+                (skipped ||= []) << current
+                next_sequence = next_sequence.nested
+                next
+              else
+                next_sequence = next_sequence.nested
+                begin
+                  target, block, method, *arguments = current.expand_call_template(env, invoke_sequence)
+                  target.send(method, *arguments, &block)
+                ensure
+                  next_sequence = current
+                end
+              end
+              current.invoke_after(env)
+              skipped.pop.invoke_after(env) while skipped&.first
+              break env.value
+            end
+          end
+
           invoke_sequence.call
         end
       end
@@ -145,7 +143,7 @@ module ActiveSupport
       # A hook invoked every time a before callback is halted.
       # This can be overridden in ActiveSupport::Callbacks implementors in order
       # to provide better debugging/logging.
-      def halted_callback_hook(filter)
+      def halted_callback_hook(filter, name)
       end
 
       module Conditionals # :nodoc:
@@ -161,17 +159,17 @@ module ActiveSupport
         Environment = Struct.new(:target, :halted, :value)
 
         class Before
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter)
+          def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter, name)
             halted_lambda = chain_config[:terminator]
 
             if user_conditions.any?
-              halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
+              halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name)
             else
-              halting(callback_sequence, user_callback, halted_lambda, filter)
+              halting(callback_sequence, user_callback, halted_lambda, filter, name)
             end
           end
 
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter)
+          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions, halted_lambda, filter, name)
             callback_sequence.before do |env|
               target = env.target
               value  = env.value
@@ -181,7 +179,7 @@ module ActiveSupport
                 result_lambda = -> { user_callback.call target, value }
                 env.halted = halted_lambda.call(target, result_lambda)
                 if env.halted
-                  target.send :halted_callback_hook, filter
+                  target.send :halted_callback_hook, filter, name
                 end
               end
 
@@ -190,7 +188,7 @@ module ActiveSupport
           end
           private_class_method :halting_and_conditional
 
-          def self.halting(callback_sequence, user_callback, halted_lambda, filter)
+          def self.halting(callback_sequence, user_callback, halted_lambda, filter, name)
             callback_sequence.before do |env|
               target = env.target
               value  = env.value
@@ -199,9 +197,8 @@ module ActiveSupport
               unless halted
                 result_lambda = -> { user_callback.call target, value }
                 env.halted = halted_lambda.call(target, result_lambda)
-
                 if env.halted
-                  target.send :halted_callback_hook, filter
+                  target.send :halted_callback_hook, filter, name
                 end
               end
 
@@ -300,8 +297,8 @@ module ActiveSupport
           @kind    = kind
           @filter  = filter
           @key     = compute_identifier filter
-          @if      = check_conditionals(Array(options[:if]))
-          @unless  = check_conditionals(Array(options[:unless]))
+          @if      = check_conditionals(options[:if])
+          @unless  = check_conditionals(options[:unless])
         end
 
         def filter; @key; end
@@ -339,7 +336,7 @@ module ActiveSupport
 
           case kind
           when :before
-            Filters::Before.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config, @filter)
+            Filters::Before.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config, @filter, name)
           when :after
             Filters::After.build(callback_sequence, user_callback.make_lambda, user_conditions, chain_config)
           when :around
@@ -352,7 +349,13 @@ module ActiveSupport
         end
 
         private
+          EMPTY_ARRAY = [].freeze
+          private_constant :EMPTY_ARRAY
+
           def check_conditionals(conditionals)
+            return EMPTY_ARRAY if conditionals.blank?
+
+            conditionals = Array(conditionals)
             if conditionals.any? { |c| c.is_a?(String) }
               raise ArgumentError, <<-MSG.squish
                 Passing string to be evaluated in :if and :unless conditional
@@ -361,7 +364,7 @@ module ActiveSupport
               MSG
             end
 
-            conditionals
+            conditionals.freeze
           end
 
           def compute_identifier(filter)
@@ -403,21 +406,17 @@ module ActiveSupport
         # The actual invocation is left up to the caller to minimize
         # call stack pollution.
         def expand(target, value, block)
-          result = @arguments.map { |arg|
+          expanded = [@override_target || target, @override_block || block, @method_name]
+
+          @arguments.each do |arg|
             case arg
-            when :value; value
-            when :target; target
-            when :block; block || raise(ArgumentError)
+            when :value then expanded << value
+            when :target then expanded << target
+            when :block then expanded << (block || raise(ArgumentError))
             end
-          }
-
-          result.unshift @method_name
-          result.unshift @override_block || block
-          result.unshift @override_target || target
+          end
 
-          # target, block, method, *arguments = result
-          # target.send(method, *arguments, &block)
-          result
+          expanded
         end
 
         # Return a lambda that will make this call when given the input
@@ -845,8 +844,18 @@ module ActiveSupport
             __callbacks[name.to_sym]
           end
 
-          def set_callbacks(name, callbacks) # :nodoc:
-            self.__callbacks = __callbacks.merge(name.to_sym => callbacks)
+          if Module.instance_method(:method_defined?).arity == 1 # Ruby 2.5 and older
+            def set_callbacks(name, callbacks) # :nodoc:
+              self.__callbacks = __callbacks.merge(name.to_sym => callbacks)
+            end
+          else # Ruby 2.6 and newer
+            def set_callbacks(name, callbacks) # :nodoc:
+              unless singleton_class.method_defined?(:__callbacks, false)
+                self.__callbacks = __callbacks.dup
+              end
+              self.__callbacks[name.to_sym] = callbacks
+              self.__callbacks
+            end
           end
       end
   end