activesupport 6.0.4 → 6.1.4

data/lib/active_support/cache.rb

@@ -3,10 +3,12 @@
 require "zlib"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/array/wrap"
+require "active_support/core_ext/enumerable"
 require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/numeric/bytes"
 require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/object/to_param"
+require "active_support/core_ext/object/try"
 require "active_support/core_ext/string/inflections"
 
 module ActiveSupport
@@ -20,7 +22,7 @@ module ActiveSupport
 
     # These options mean something to all cache implementations. Individual cache
     # implementations may support additional options.
-    UNIVERSAL_OPTIONS = [:namespace, :compress, :compress_threshold, :expires_in, :race_condition_ttl]
+    UNIVERSAL_OPTIONS = [:namespace, :compress, :compress_threshold, :expires_in, :race_condition_ttl, :coder]
 
     module Strategy
       autoload :LocalCache, "active_support/cache/strategy/local_cache"
@@ -56,7 +58,13 @@ module ActiveSupport
         case store
         when Symbol
           options = parameters.extract_options!
-          retrieve_store_class(store).new(*parameters, **options)
+          # clean this up once Ruby 2.7 support is dropped
+          # see https://github.com/rails/rails/pull/41522#discussion_r581186602
+          if options.empty?
+            retrieve_store_class(store).new(*parameters)
+          else
+            retrieve_store_class(store).new(*parameters, **options)
+          end
         when Array
           lookup_store(*store)
         when nil
@@ -79,7 +87,7 @@ module ActiveSupport
       #
       # The +key+ argument can also respond to +cache_key+ or +to_param+.
       def expand_cache_key(key, namespace = nil)
-        expanded_cache_key = (namespace ? "#{namespace}/" : "").dup
+        expanded_cache_key = namespace ? +"#{namespace}/" : +""
 
         if prefix = ENV["RAILS_CACHE_ID"] || ENV["RAILS_APP_VERSION"]
           expanded_cache_key << "#{prefix}/"
@@ -156,6 +164,8 @@ module ActiveSupport
     # threshold is configurable with the <tt>:compress_threshold</tt> option,
     # specified in bytes.
     class Store
+      DEFAULT_CODER = Marshal
+
       cattr_accessor :logger, instance_writer: true
 
       attr_reader :silence, :options
@@ -183,6 +193,7 @@ module ActiveSupport
       # namespace for the cache.
       def initialize(options = nil)
         @options = options ? options.dup : {}
+        @coder = @options.delete(:coder) { self.class::DEFAULT_CODER } || NullCoder
       end
 
       # Silences the logger.
@@ -319,7 +330,7 @@ module ActiveSupport
 
           entry = nil
           instrument(:read, name, options) do |payload|
-            cached_entry = read_entry(key, **options) unless options[:force]
+            cached_entry = read_entry(key, **options, event: payload) unless options[:force]
             entry = handle_expired_entry(cached_entry, key, options)
             entry = nil if entry && entry.mismatched?(normalize_version(name, options))
             payload[:super_operation] = :fetch if payload
@@ -353,7 +364,7 @@ module ActiveSupport
         version = normalize_version(name, options)
 
         instrument(:read, name, options) do |payload|
-          entry = read_entry(key, **options)
+          entry = read_entry(key, **options, event: payload)
 
           if entry
             if entry.expired?
@@ -385,7 +396,7 @@ module ActiveSupport
         options = merged_options(options)
 
         instrument :read_multi, names, options do |payload|
-          read_multi_entries(names, **options).tap do |results|
+          read_multi_entries(names, **options, event: payload).tap do |results|
             payload[:hits] = results.keys
           end
         end
@@ -441,8 +452,8 @@ module ActiveSupport
         instrument :read_multi, names, options do |payload|
           reads   = read_multi_entries(names, **options)
           writes  = {}
-          ordered = names.each_with_object({}) do |name, hash|
-            hash[name] = reads.fetch(name) { writes[name] = yield(name) }
+          ordered = names.index_with do |name|
+            reads.fetch(name) { writes[name] = yield(name) }
           end
 
           payload[:hits] = reads.keys
@@ -477,14 +488,26 @@ module ActiveSupport
         end
       end
 
+      # Deletes multiple entries in the cache.
+      #
+      # Options are passed to the underlying cache implementation.
+      def delete_multi(names, options = nil)
+        options = merged_options(options)
+        names.map! { |key| normalize_key(key, options) }
+
+        instrument :delete_multi, names do
+          delete_multi_entries(names, **options)
+        end
+      end
+
       # Returns +true+ if the cache contains an entry for the given key.
       #
       # Options are passed to the underlying cache implementation.
       def exist?(name, options = nil)
         options = merged_options(options)
 
-        instrument(:exist?, name) do
-          entry = read_entry(normalize_key(name, options), **options)
+        instrument(:exist?, name) do |payload|
+          entry = read_entry(normalize_key(name, options), **options, event: payload)
           (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
         end
       end
@@ -567,26 +590,31 @@ module ActiveSupport
           raise NotImplementedError.new
         end
 
+        def serialize_entry(entry)
+          @coder.dump(entry)
+        end
+
+        def deserialize_entry(payload)
+          payload.nil? ? nil : @coder.load(payload)
+        end
+
         # Reads multiple entries from the cache implementation. Subclasses MAY
         # implement this method.
         def read_multi_entries(names, **options)
-          results = {}
-          names.each do |name|
-            key     = normalize_key(name, options)
+          names.each_with_object({}) do |name, results|
+            key   = normalize_key(name, options)
+            entry = read_entry(key, **options)
+
+            next unless entry
+
             version = normalize_version(name, options)
-            entry   = read_entry(key, **options)
-
-            if entry
-              if entry.expired?
-                delete_entry(key, **options)
-              elsif entry.mismatched?(version)
-                # Skip mismatched versions
-              else
-                results[name] = entry.value
-              end
+
+            if entry.expired?
+              delete_entry(key, **options)
+            elsif !entry.mismatched?(version)
+              results[name] = entry.value
             end
           end
-          results
         end
 
         # Writes multiple entries to the cache implementation. Subclasses MAY
@@ -603,6 +631,12 @@ module ActiveSupport
           raise NotImplementedError.new
         end
 
+        # Deletes multiples entries in the cache implementation. Subclasses MAY
+        # implement this method.
+        def delete_multi_entries(entries, **options)
+          entries.count { |key| delete_entry(key, **options) }
+        end
+
         # Merges the default options with ones specific to a method call.
         def merged_options(call_options)
           if call_options
@@ -639,6 +673,10 @@ module ActiveSupport
             namespace = namespace.call
           end
 
+          if key && key.encoding != Encoding::UTF_8
+            key = key.dup.force_encoding(Encoding::UTF_8)
+          end
+
           if namespace
             "#{namespace}:#{key}"
           else
@@ -655,15 +693,15 @@ module ActiveSupport
           case key
           when Array
             if key.size > 1
-              key = key.collect { |element| expanded_key(element) }
+              key.collect { |element| expanded_key(element) }
             else
-              key = expanded_key(key.first)
+              expanded_key(key.first)
             end
           when Hash
-            key = key.sort_by { |k, _| k.to_s }.collect { |k, v| "#{k}=#{v}" }
-          end
-
-          key.to_param
+            key.collect { |k, v| "#{k}=#{v}" }.sort!
+          else
+            key
+          end.to_param
         end
 
         def normalize_version(key, options = nil)
@@ -673,24 +711,21 @@ module ActiveSupport
         def expanded_version(key)
           case
           when key.respond_to?(:cache_version) then key.cache_version.to_param
-          when key.is_a?(Array)                then key.map { |element| expanded_version(element) }.compact.to_param
+          when key.is_a?(Array)                then key.map { |element| expanded_version(element) }.tap(&:compact!).to_param
           when key.respond_to?(:to_a)          then expanded_version(key.to_a)
           end
         end
 
         def instrument(operation, key, options = nil)
-          log { "Cache #{operation}: #{normalize_key(key, options)}#{options.blank? ? "" : " (#{options.inspect})"}" }
+          if logger && logger.debug? && !silence?
+            logger.debug "Cache #{operation}: #{normalize_key(key, options)}#{options.blank? ? "" : " (#{options.inspect})"}"
+          end
 
-          payload = { key: key }
+          payload = { key: key, store: self.class.name }
           payload.merge!(options) if options.is_a?(Hash)
           ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) { yield(payload) }
         end
 
-        def log
-          return unless logger && logger.debug? && !silence?
-          logger.debug(yield)
-        end
-
         def handle_expired_entry(entry, key, options)
           if entry && entry.expired?
             race_ttl = options[:race_condition_ttl].to_i
@@ -722,6 +757,18 @@ module ActiveSupport
         end
     end
 
+    module NullCoder # :nodoc:
+      class << self
+        def load(payload)
+          payload
+        end
+
+        def dump(entry)
+          entry
+        end
+      end
+    end
+
     # This class is used to represent cache entries. Cache entries have a value, an optional
     # expiration time, and an optional version. The expiration time is used to support the :race_condition_ttl option
     # on the cache. The version is used to support the :version option on the cache for rejecting
@@ -772,8 +819,8 @@ module ActiveSupport
       end
 
       # Returns the size of the cached value. This could be less than
-      # <tt>value.size</tt> if the data is compressed.
-      def size
+      # <tt>value.bytesize</tt> if the data is compressed.
+      def bytesize
         case value
         when NilClass
           0

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

data/lib/active_support/concern.rb

@@ -19,7 +19,7 @@ module ActiveSupport
   # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
   # written as:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module M
   #     extend ActiveSupport::Concern
@@ -76,7 +76,7 @@ module ActiveSupport
   # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
   # module dependencies are properly resolved:
   #
-  #   require 'active_support/concern'
+  #   require "active_support/concern"
   #
   #   module Foo
   #     extend ActiveSupport::Concern
@@ -99,6 +99,14 @@ module ActiveSupport
   #   class Host
   #     include Bar # It works, now Bar takes care of its dependencies
   #   end
+  #
+  # === Prepending concerns
+  #
+  # Just like <tt>include</tt>, concerns also support <tt>prepend</tt> with a corresponding
+  # <tt>prepended do</tt> callback. <tt>module ClassMethods</tt> or <tt>class_methods do</tt> are
+  # prepended as well.
+  #
+  # <tt>prepend</tt> is also used for any dependencies.
   module Concern
     class MultipleIncludedBlocks < StandardError #:nodoc:
       def initialize
@@ -106,6 +114,12 @@ module ActiveSupport
       end
     end
 
+    class MultiplePrependBlocks < StandardError #:nodoc:
+      def initialize
+        super "Cannot define multiple 'prepended' blocks for a Concern"
+      end
+    end
+
     def self.extended(base) #:nodoc:
       base.instance_variable_set(:@_dependencies, [])
     end
@@ -123,6 +137,19 @@ module ActiveSupport
       end
     end
 
+    def prepend_features(base) #:nodoc:
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies).unshift self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.prepend(dep) }
+        super
+        base.singleton_class.prepend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        base.class_eval(&@_prepended_block) if instance_variable_defined?(:@_prepended_block)
+      end
+    end
+
     # Evaluate given block in context of base class,
     # so that you can write class macros here.
     # When you define more than one +included+ block, it raises an exception.
@@ -140,6 +167,23 @@ module ActiveSupport
       end
     end
 
+    # Evaluate given block in context of base class,
+    # so that you can write class macros here.
+    # When you define more than one +prepended+ block, it raises an exception.
+    def prepended(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_prepended_block)
+          if @_prepended_block.source_location != block.source_location
+            raise MultiplePrependBlocks
+          end
+        else
+          @_prepended_block = block
+        end
+      else
+        super
+      end
+    end
+
     # Define class methods from given block.
     # You can define private class methods as well.
     #

data/lib/active_support/configurable.rb

@@ -5,7 +5,7 @@ require "active_support/ordered_options"
 
 module ActiveSupport
   # Configurable provides a <tt>config</tt> method to store and retrieve
-  # configuration options as an <tt>OrderedHash</tt>.
+  # configuration options as an <tt>OrderedOptions</tt>.
   module Configurable
     extend ActiveSupport::Concern
 
@@ -124,9 +124,9 @@ module ActiveSupport
       private :config_accessor
     end
 
-    # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
+    # Reads and writes attributes from a configuration <tt>OrderedOptions</tt>.
     #
-    #   require 'active_support/configurable'
+    #   require "active_support/configurable"
     #
     #   class User
     #     include ActiveSupport::Configurable

data/lib/active_support/configuration_file.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Reads a YAML configuration file, evaluating any ERB, then
+  # parsing the resulting YAML.
+  #
+  # Warns in case of YAML confusing characters, like invisible
+  # non-breaking spaces.
+  class ConfigurationFile # :nodoc:
+    class FormatError < StandardError; end
+
+    def initialize(content_path)
+      @content_path = content_path.to_s
+      @content = read content_path
+    end
+
+    def self.parse(content_path, **options)
+      new(content_path).parse(**options)
+    end
+
+    def parse(context: nil, **options)
+      source = render(context)
+      if YAML.respond_to?(:unsafe_load)
+        YAML.unsafe_load(source, **options) || {}
+      else
+        YAML.load(source, **options) || {}
+      end
+    rescue Psych::SyntaxError => error
+      raise "YAML syntax error occurred while parsing #{@content_path}. " \
+            "Please note that YAML must be consistently indented using spaces. Tabs are not allowed. " \
+            "Error: #{error.message}"
+    end
+
+    private
+      def read(content_path)
+        require "yaml"
+        require "erb"
+
+        File.read(content_path).tap do |content|
+          if content.include?("\u00A0")
+            warn "File contains invisible non-breaking spaces, you may want to remove those"
+          end
+        end
+      end
+
+      def render(context)
+        erb = ERB.new(@content).tap { |e| e.filename = @content_path }
+        context ? erb.result(context) : erb.result
+      end
+  end
+end

data/lib/active_support/core_ext/benchmark.rb

@@ -10,7 +10,7 @@ class << Benchmark
   #
   #   Benchmark.ms { User.all }
   #   # => 0.074
-  def ms
-    1000 * realtime { yield }
+  def ms(&block)
+    1000 * realtime(&block)
   end
 end