activesupport 7.2.3 → 8.0.0.beta1

data/lib/active_support/broadcast_logger.rb

@@ -76,6 +76,7 @@ module ActiveSupport
 
     # Returns all the logger that are part of this broadcast.
     attr_reader :broadcasts
+    attr_reader :formatter
     attr_accessor :progname
 
     def initialize(*loggers)
@@ -104,119 +105,131 @@ module ActiveSupport
       @broadcasts.delete(logger)
     end
 
-    def local_level=(level)
-      @broadcasts.each do |logger|
-        logger.local_level = level if logger.respond_to?(:local_level=)
-      end
+    def level
+      @broadcasts.map(&:level).min
     end
 
-    def local_level
-      loggers = @broadcasts.select { |logger| logger.respond_to?(:local_level) }
+    def <<(message)
+      dispatch { |logger| logger.<<(message) }
+    end
 
-      loggers.map do |logger|
-        logger.local_level
-      end.first
+    def add(...)
+      dispatch { |logger| logger.add(...) }
     end
+    alias_method :log, :add
 
-    LOGGER_METHODS = %w[
-      << log add debug info warn error fatal unknown
-      level= sev_threshold= close
-      formatter formatter=
-    ] # :nodoc:
-    LOGGER_METHODS.each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__ + 1
-        def #{method}(...)
-          dispatch(:#{method}, ...)
-        end
-      RUBY
+    def debug(...)
+      dispatch { |logger| logger.debug(...) }
     end
 
-    # Returns the lowest level of all the loggers in the broadcast.
-    def level
-      @broadcasts.map(&:level).min
+    def info(...)
+      dispatch { |logger| logger.info(...) }
+    end
+
+    def warn(...)
+      dispatch { |logger| logger.warn(...) }
+    end
+
+    def error(...)
+      dispatch { |logger| logger.error(...) }
+    end
+
+    def fatal(...)
+      dispatch { |logger| logger.fatal(...) }
     end
 
-    # True if the log level allows entries with severity +Logger::DEBUG+ to be written
-    # to at least one broadcast. False otherwise.
+    def unknown(...)
+      dispatch { |logger| logger.unknown(...) }
+    end
+
+    def formatter=(formatter)
+      dispatch { |logger| logger.formatter = formatter }
+
+      @formatter = formatter
+    end
+
+    def level=(level)
+      dispatch { |logger| logger.level = level }
+    end
+    alias_method :sev_threshold=, :level=
+
+    def local_level=(level)
+      dispatch do |logger|
+        logger.local_level = level if logger.respond_to?(:local_level=)
+      end
+    end
+
+    def close
+      dispatch { |logger| logger.close }
+    end
+
+    # +True+ if the log level allows entries with severity Logger::DEBUG to be written
+    # to at least one broadcast. +False+ otherwise.
     def debug?
       @broadcasts.any? { |logger| logger.debug? }
     end
 
-    # Sets the log level to +Logger::DEBUG+ for the whole broadcast.
+    # Sets the log level to Logger::DEBUG for the whole broadcast.
     def debug!
-      dispatch(:debug!)
+      dispatch { |logger| logger.debug! }
     end
 
-    # True if the log level allows entries with severity +Logger::INFO+ to be written
-    # to at least one broadcast. False otherwise.
+    # +True+ if the log level allows entries with severity Logger::INFO to be written
+    # to at least one broadcast. +False+ otherwise.
     def info?
       @broadcasts.any? { |logger| logger.info? }
     end
 
-    # Sets the log level to +Logger::INFO+ for the whole broadcast.
+    # Sets the log level to Logger::INFO for the whole broadcast.
     def info!
-      dispatch(:info!)
+      dispatch { |logger| logger.info! }
     end
 
-    # True if the log level allows entries with severity +Logger::WARN+ to be written
-    # to at least one broadcast. False otherwise.
+    # +True+ if the log level allows entries with severity Logger::WARN to be written
+    # to at least one broadcast. +False+ otherwise.
     def warn?
       @broadcasts.any? { |logger| logger.warn? }
     end
 
-    # Sets the log level to +Logger::WARN+ for the whole broadcast.
+    # Sets the log level to Logger::WARN for the whole broadcast.
     def warn!
-      dispatch(:warn!)
+      dispatch { |logger| logger.warn! }
     end
 
-    # True if the log level allows entries with severity +Logger::ERROR+ to be written
-    # to at least one broadcast. False otherwise.
+    # +True+ if the log level allows entries with severity Logger::ERROR to be written
+    # to at least one broadcast. +False+ otherwise.
     def error?
       @broadcasts.any? { |logger| logger.error? }
     end
 
-    # Sets the log level to +Logger::ERROR+ for the whole broadcast.
+    # Sets the log level to Logger::ERROR for the whole broadcast.
     def error!
-      dispatch(:error!)
+      dispatch { |logger| logger.error! }
     end
 
-    # True if the log level allows entries with severity +Logger::FATAL+ to be written
-    # to at least one broadcast. False otherwise.
+    # +True+ if the log level allows entries with severity Logger::FATAL to be written
+    # to at least one broadcast. +False+ otherwise.
     def fatal?
       @broadcasts.any? { |logger| logger.fatal? }
     end
 
-    # Sets the log level to +Logger::FATAL+ for the whole broadcast.
+    # Sets the log level to Logger::FATAL for the whole broadcast.
     def fatal!
-      dispatch(:fatal!)
+      dispatch { |logger| logger.fatal! }
     end
 
     def initialize_copy(other)
       @broadcasts = []
       @progname = other.progname.dup
+      @formatter = other.formatter.dup
 
       broadcast_to(*other.broadcasts.map(&:dup))
     end
 
     private
-      def dispatch(method, *args, **kwargs, &block)
-        if block_given?
-          # Maintain semantics that the first logger yields the block
-          # as normal, but subsequent loggers won't re-execute the block.
-          # Instead, the initial result is immediately returned.
-          called, result = false, nil
-          block = proc { |*args, **kwargs|
-            if called then result
-            else
-              called = true
-              result = yield(*args, **kwargs)
-            end
-          }
-        end
-
-        @broadcasts.map { |logger|
-          logger.send(method, *args, **kwargs, &block)
-        }.first
+      def dispatch(&block)
+        @broadcasts.each { |logger| block.call(logger) }
+        true
       end
 
       def method_missing(name, ...)

data/lib/active_support/cache/file_store.rb

@@ -57,8 +57,13 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, **options)
-        modify_value(name, amount, options)
+      def increment(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:increment, key, amount: amount) do
+          modify_value(name, amount, options)
+        end
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -72,8 +77,13 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, **options)
-        modify_value(name, -amount, options)
+      def decrement(name, amount = 1, options = nil)
+        options = merged_options(options)
+        key = normalize_key(name, options)
+
+        instrument(:decrement, key, amount: amount) do
+          modify_value(name, -amount, options)
+        end
       end
 
       def delete_matched(matcher, options = nil)

data/lib/active_support/cache/mem_cache_store.rb

@@ -212,24 +212,26 @@ module ActiveSupport
         def read_multi_entries(names, **options)
           keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
-          rescue_error_with({}) do
-            raw_values = @data.with { |c| c.get_multi(keys_to_names.keys) }
+          raw_values = begin
+            @data.with { |c| c.get_multi(keys_to_names.keys) }
+          rescue Dalli::UnmarshalError
+            {}
+          end
 
-            values = {}
+          values = {}
 
-            raw_values.each do |key, value|
-              entry = deserialize_entry(value, raw: options[:raw])
+          raw_values.each do |key, value|
+            entry = deserialize_entry(value, raw: options[:raw])
 
-              unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
-                begin
-                  values[keys_to_names[key]] = entry.value
-                rescue DeserializationError
-                end
+            unless entry.nil? || entry.expired? || entry.mismatched?(normalize_version(keys_to_names[key], options))
+              begin
+                values[keys_to_names[key]] = entry.value
+              rescue DeserializationError
               end
             end
-
-            values
           end
+
+          values
         end
 
         # Delete an entry from the cache.
@@ -274,7 +276,7 @@ module ActiveSupport
 
         def rescue_error_with(fallback)
           yield
-        rescue Dalli::DalliError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
+        rescue Dalli::DalliError => error
           logger.error("DalliError (#{error}): #{error.message}") if logger
           ActiveSupport.error_reporter&.report(
             error,

data/lib/active_support/cache/memory_store.rb

@@ -146,8 +146,10 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.increment("baz") # => 6
       #
-      def increment(name, amount = 1, **options)
-        modify_value(name, amount, **options)
+      def increment(name, amount = 1, options = nil)
+        instrument(:increment, name, amount: amount) do
+          modify_value(name, amount, options)
+        end
       end
 
       # Decrement a cached integer value. Returns the updated value.
@@ -161,8 +163,10 @@ module ActiveSupport
       #   cache.write("baz", 5)
       #   cache.decrement("baz") # => 4
       #
-      def decrement(name, amount = 1, **options)
-        modify_value(name, -amount, **options)
+      def decrement(name, amount = 1, options = nil)
+        instrument(:decrement, name, amount: amount) do
+          modify_value(name, -amount, options)
+        end
       end
 
       # Deletes cache entries if the cache key matches a given pattern.
@@ -234,7 +238,7 @@ module ActiveSupport
 
         # Modifies the amount of an integer value that is stored in the cache.
         # If the key is not found it is created and set to +amount+.
-        def modify_value(name, amount, **options)
+        def modify_value(name, amount, options)
           options = merged_options(options)
           key     = normalize_key(name, options)
           version = normalize_version(name, options)

data/lib/active_support/cache/null_store.rb

@@ -25,10 +25,10 @@ module ActiveSupport
       def cleanup(options = nil)
       end
 
-      def increment(name, amount = 1, **options)
+      def increment(name, amount = 1, options = nil)
       end
 
-      def decrement(name, amount = 1, **options)
+      def decrement(name, amount = 1, options = nil)
       end
 
       def delete_matched(matcher, options = nil)

data/lib/active_support/cache/redis_cache_store.rb

@@ -173,9 +173,12 @@ module ActiveSupport
         return {} if names.empty?
 
         options = names.extract_options!
-        instrument_multi(:read_multi, names, options) do |payload|
+        options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
+
+        instrument_multi(:read_multi, keys, options) do |payload|
           read_multi_entries(names, **options).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end
@@ -480,7 +483,7 @@ module ActiveSupport
 
         def failsafe(method, returning: nil)
           yield
-        rescue ::Redis::BaseError, ConnectionPool::Error, ConnectionPool::TimeoutError => error
+        rescue ::Redis::BaseError => error
           @error_handler&.call(method: method, exception: error, returning: returning)
           returning
         end

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

@@ -94,52 +94,26 @@ module ActiveSupport
           super
         end
 
-        def increment(name, amount = 1, **options) # :nodoc:
+        def increment(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, raw: true, **options)
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
+          end
           value
         end
 
-        def decrement(name, amount = 1, **options) # :nodoc:
+        def decrement(name, amount = 1, options = nil) # :nodoc:
           return super unless local_cache
           value = bypass_local_cache { super }
-          write_cache_value(name, value, raw: true, **options)
-          value
-        end
-
-        def fetch_multi(*names, &block) # :nodoc:
-          return super if local_cache.nil? || names.empty?
-
-          options = names.extract_options!
-          options = merged_options(options)
-
-          keys_to_names = names.index_by { |name| normalize_key(name, options) }
-
-          local_entries = local_cache.read_multi_entries(keys_to_names.keys)
-          results = local_entries.each_with_object({}) do |(key, value), result|
-            # If we recorded a miss in the local cache, `#fetch_multi` will forward
-            # that key to the real store, and the entry will be replaced
-            # local_cache.delete_entry(key)
-            next if value.nil?
-
-            entry = deserialize_entry(value, **options)
-
-            normalized_key = keys_to_names[key]
-            if entry.nil?
-              result[normalized_key] = nil
-            elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
-              local_cache.delete_entry(key)
-            else
-              result[normalized_key] = entry.value
-            end
+          if options
+            write_cache_value(name, value, raw: true, **options)
+          else
+            write_cache_value(name, value, raw: true)
           end
-
-          if results.size < names.size
-            results.merge!(super(*(names - results.keys), options, &block))
-          end
-
-          results
+          value
         end
 
         private
@@ -163,27 +137,17 @@ module ActiveSupport
             keys_to_names = names.index_by { |name| normalize_key(name, options) }
 
             local_entries = local_cache.read_multi_entries(keys_to_names.keys)
-
-            results = local_entries.each_with_object({}) do |(key, value), result|
-              next if value.nil? # recorded cache miss
-
-              entry = deserialize_entry(value, **options)
-
-              normalized_key = keys_to_names[key]
-              if entry.nil?
-                result[normalized_key] = nil
-              elsif entry.expired? || entry.mismatched?(normalize_version(normalized_key, options))
-                local_cache.delete_entry(key)
-              else
-                result[normalized_key] = entry.value
-              end
+            local_entries.transform_keys! { |key| keys_to_names[key] }
+            local_entries.transform_values! do |payload|
+              deserialize_entry(payload, **options)&.value
             end
+            missed_names = names - local_entries.keys
 
-            if results.size < names.size
-              results.merge!(super(names - results.keys, **options))
+            if missed_names.any?
+              local_entries.merge!(super(missed_names, **options))
+            else
+              local_entries
             end
-
-            results
           end
 
           def write_serialized_entry(key, payload, **)

data/lib/active_support/cache.rb

@@ -35,7 +35,6 @@ module ActiveSupport
       :race_condition_ttl,
       :serializer,
       :skip_nil,
-      :raw,
     ]
 
     # Mapping of canonical option names to aliases that a store will recognize.
@@ -387,7 +386,7 @@ module ActiveSupport
       #   process can try to generate a new value after the extended time window
       #   has elapsed.
       #
-      #     # Set all values to expire after one second.
+      #     # Set all values to expire after one minute.
       #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
       #     cache.write("foo", "original value")
@@ -539,10 +538,11 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
+        keys    = names.map { |name| normalize_key(name, options) }
 
-        instrument_multi :read_multi, names, options do |payload|
+        instrument_multi :read_multi, keys, options do |payload|
           read_multi_entries(names, **options, event: payload).tap do |results|
-            payload[:hits] = results.keys
+            payload[:hits] = results.keys.map { |name| normalize_key(name, options) }
           end
         end
       end
@@ -552,8 +552,9 @@ module ActiveSupport
         return hash if hash.empty?
 
         options = merged_options(options)
+        normalized_hash = hash.transform_keys { |key| normalize_key(key, options) }
 
-        instrument_multi :write_multi, hash, options do |payload|
+        instrument_multi :write_multi, normalized_hash, options do |payload|
           entries = hash.each_with_object({}) do |(name, value), memo|
             memo[normalize_key(name, options)] = Entry.new(value, **options.merge(version: normalize_version(name, options)))
           end
@@ -597,9 +598,9 @@ module ActiveSupport
 
         options = names.extract_options!
         options = merged_options(options)
-
+        keys    = names.map { |name| normalize_key(name, options) }
         writes  = {}
-        ordered = instrument_multi :read_multi, names, options do |payload|
+        ordered = instrument_multi :read_multi, keys, options do |payload|
           if options[:force]
             reads = {}
           else
@@ -611,7 +612,7 @@ module ActiveSupport
           end
           writes.compact! if options[:skip_nil]
 
-          payload[:hits] = reads.keys
+          payload[:hits] = reads.keys.map { |name| normalize_key(name, options) }
           payload[:super_operation] = :fetch_multi
 
           ordered
@@ -944,9 +945,12 @@ module ActiveSupport
         #
         #   namespace_key 'foo', namespace: -> { 'cache' }
         #   # => 'cache:foo'
-        def namespace_key(key, options = nil)
-          options = merged_options(options)
-          namespace = options[:namespace]
+        def namespace_key(key, call_options = nil)
+          namespace = if call_options&.key?(:namespace)
+            call_options[:namespace]
+          else
+            options[:namespace]
+          end
 
           if namespace.respond_to?(:call)
             namespace = namespace.call
@@ -1031,7 +1035,8 @@ module ActiveSupport
               # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
               # for a brief period while the entry is being recalculated.
               entry.expires_at = Time.now.to_f + race_ttl
-              write_entry(key, entry, **options, expires_in: race_ttl * 2)
+              options[:expires_in] = race_ttl * 2
+              write_entry(key, entry, **options)
             else
               delete_entry(key, **options)
             end

data/lib/active_support/callbacks.rb

@@ -6,7 +6,6 @@ require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/class/attribute"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/object/blank"
-require "thread"
 
 module ActiveSupport
   # = Active Support \Callbacks
@@ -67,7 +66,7 @@ module ActiveSupport
 
     included do
       extend ActiveSupport::DescendantsTracker
-      class_attribute :__callbacks, instance_writer: false, default: {}
+      class_attribute :__callbacks, instance_writer: false, instance_predicate: false, default: {}
     end
 
     CALLBACK_FILTER_TYPES = [:before, :after, :around].freeze
@@ -499,10 +498,9 @@ module ActiveSupport
           when Conditionals::Value
             ProcCall.new(filter)
           when ::Proc
-            case filter.arity
-            when 2
+            if filter.arity > 1
               InstanceExec2.new(filter)
-            when 1, -2
+            elsif filter.arity > 0
               InstanceExec1.new(filter)
             else
               InstanceExec0.new(filter)

data/lib/active_support/class_attribute.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ClassAttribute # :nodoc:
+    class << self
+      def redefine(owner, name, value)
+        if owner.singleton_class?
+          owner.redefine_method(name) { value }
+          owner.send(:public, name)
+        end
+
+        owner.redefine_singleton_method(name) { value }
+        owner.singleton_class.send(:public, name)
+
+        owner.redefine_singleton_method("#{name}=") do |new_value|
+          if owner.equal?(self)
+            value = new_value
+          else
+            ::ActiveSupport::ClassAttribute.redefine(self, name, new_value)
+          end
+        end
+        owner.singleton_class.send(:public, "#{name}=")
+      end
+    end
+  end
+end

data/lib/active_support/code_generator.rb

@@ -55,6 +55,11 @@ module ActiveSupport
       @path = path
       @line = line
       @namespaces = Hash.new { |h, k| h[k] = MethodSet.new(k) }
+      @sources = []
+    end
+
+    def class_eval
+      yield @sources
     end
 
     def define_cached_method(canonical_name, namespace:, as: nil, &block)
@@ -65,6 +70,10 @@ module ActiveSupport
       @namespaces.each_value do |method_set|
         method_set.apply(@owner, @path, @line - 1)
       end
+
+      unless @sources.empty?
+        @owner.class_eval("# frozen_string_literal: true\n" + @sources.join(";"), @path, @line - 1)
+      end
     end
   end
 end

data/lib/active_support/concurrency/share_lock.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "thread"
 require "monitor"
 
 module ActiveSupport

data/lib/active_support/configuration_file.rb

@@ -19,11 +19,20 @@ module ActiveSupport
     end
 
     def parse(context: nil, **options)
-      source = render(context)
-      if YAML.respond_to?(:unsafe_load)
-        YAML.unsafe_load(source, **options) || {}
+      source = @content.include?("<%") ? render(context) : @content
+
+      if source == @content
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load_file(@content_path, **options) || {}
+        else
+          YAML.load_file(@content_path, **options) || {}
+        end
       else
-        YAML.load(source, **options) || {}
+        if YAML.respond_to?(:unsafe_load)
+          YAML.unsafe_load(source, **options) || {}
+        else
+          YAML.load(source, **options) || {}
+        end
       end
     rescue Psych::SyntaxError => error
       raise "YAML syntax error occurred while parsing #{@content_path}. " \
@@ -33,8 +42,7 @@ module ActiveSupport
 
     private
       def read(content_path)
-        require "yaml"
-        require "erb"
+        require "yaml" unless defined?(YAML)
 
         File.read(content_path).tap do |content|
           if content.include?("\u00A0")
@@ -44,6 +52,7 @@ module ActiveSupport
       end
 
       def render(context)
+        require "erb" unless defined?(ERB)
         erb = ERB.new(@content).tap { |e| e.filename = @content_path }
         context ? erb.result(context) : erb.result
       end