activesupport 7.1.4.1 → 7.2.2.1

data/lib/active_support/cache.rb

@@ -52,7 +52,7 @@ module ActiveSupport
       autoload :LocalCache, "active_support/cache/strategy/local_cache"
     end
 
-    @format_version = 6.1
+    @format_version = 7.0
 
     class << self
       attr_accessor :format_version
@@ -86,13 +86,7 @@ module ActiveSupport
         case store
         when Symbol
           options = parameters.extract_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
+          retrieve_store_class(store).new(*parameters, **options)
         when Array
           lookup_store(*store)
         when nil
@@ -166,7 +160,7 @@ module ActiveSupport
     #   cache = ActiveSupport::Cache::MemoryStore.new
     #
     #   cache.read('city')   # => nil
-    #   cache.write('city', "Duckburgh")
+    #   cache.write('city', "Duckburgh") # => true
     #   cache.read('city')   # => "Duckburgh"
     #
     #   cache.write('not serializable', Proc.new {}) # => TypeError
@@ -206,24 +200,6 @@ module ActiveSupport
           def retrieve_pool_options(options)
             if options.key?(:pool)
               pool_options = options.delete(:pool)
-            elsif options.key?(:pool_size) || options.key?(:pool_timeout)
-              pool_options = {}
-
-              if options.key?(:pool_size)
-                ActiveSupport.deprecator.warn(<<~MSG)
-                  Using :pool_size is deprecated and will be removed in Rails 7.2.
-                  Use `pool: { size: #{options[:pool_size].inspect} }` instead.
-                MSG
-                pool_options[:size] = options.delete(:pool_size)
-              end
-
-              if options.key?(:pool_timeout)
-                ActiveSupport.deprecator.warn(<<~MSG)
-                  Using :pool_timeout is deprecated and will be removed in Rails 7.2.
-                  Use `pool: { timeout: #{options[:pool_timeout].inspect} }` instead.
-                MSG
-                pool_options[:timeout] = options.delete(:pool_timeout)
-              end
             else
               pool_options = true
             end
@@ -344,7 +320,7 @@ module ActiveSupport
 
       # Silences the logger within a block.
       def mute
-        previous_silence, @silence = defined?(@silence) && @silence, true
+        previous_silence, @silence = @silence, true
         yield
       ensure
         @silence = previous_silence
@@ -411,31 +387,47 @@ module ActiveSupport
       #   has elapsed.
       #
       #     # Set all values to expire after one minute.
-      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1.minute)
+      #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
-      #     cache.write('foo', 'original value')
+      #     cache.write("foo", "original value")
       #     val_1 = nil
       #     val_2 = nil
-      #     sleep 60
+      #     p cache.read("foo") # => "original value"
       #
-      #     Thread.new do
-      #       val_1 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
+      #     sleep 1 # wait until the cache expires
+      #
+      #     t1 = Thread.new do
+      #       # fetch does the following:
+      #       # 1. gets an recent expired entry
+      #       # 2. extends the expiry by 2 seconds (race_condition_ttl)
+      #       # 3. regenerates the new value
+      #       val_1 = cache.fetch("foo", race_condition_ttl: 2) do
       #         sleep 1
-      #         'new value 1'
+      #         "new value 1"
       #       end
       #     end
       #
-      #     Thread.new do
-      #       val_2 = cache.fetch('foo', race_condition_ttl: 10.seconds) do
-      #         'new value 2'
-      #       end
+      #     # Wait until t1 extends the expiry of the entry
+      #     # but before generating the new value
+      #     sleep 0.1
+      #
+      #     val_2 = cache.fetch("foo", race_condition_ttl: 2) do
+      #       # This block won't be executed because t1 extended the expiry
+      #       "new value 2"
       #     end
       #
-      #     cache.fetch('foo') # => "original value"
-      #     sleep 10 # First thread extended the life of cache by another 10 seconds
-      #     cache.fetch('foo') # => "new value 1"
-      #     val_1 # => "new value 1"
-      #     val_2 # => "original value"
+      #     t1.join
+      #
+      #     p val_1 # => "new value 1"
+      #     p val_2 # => "oritinal value"
+      #     p cache.fetch("foo") # => "new value 1"
+      #
+      #     # The entry requires 3 seconds to expire (expires_in + race_condition_ttl)
+      #     # We have waited 2 seconds already (sleep(1) + t1.join) thus we need to wait 1
+      #     # more second to see the entry expire.
+      #     sleep 1
+      #
+      #     p cache.fetch("foo") # => nil
       #
       # ==== Dynamic Options
       #
@@ -456,7 +448,7 @@ module ActiveSupport
 
           entry = nil
           unless options[:force]
-            instrument(:read, name, options) do |payload|
+            instrument(:read, key, options) do |payload|
               cached_entry = read_entry(key, **options, event: payload)
               entry = handle_expired_entry(cached_entry, key, options)
               if entry
@@ -478,7 +470,7 @@ module ActiveSupport
           if entry
             get_entry_value(entry, name, options)
           else
-            save_block_result_to_cache(name, options, &block)
+            save_block_result_to_cache(name, key, options, &block)
           end
         elsif options && options[:force]
           raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
@@ -508,7 +500,7 @@ module ActiveSupport
         key     = normalize_key(name, options)
         version = normalize_version(name, options)
 
-        instrument(:read, name, options) do |payload|
+        instrument(:read, key, options) do |payload|
           entry = read_entry(key, **options, event: payload)
 
           if entry
@@ -605,14 +597,14 @@ module ActiveSupport
         options = names.extract_options!
         options = merged_options(options)
 
-        instrument_multi :read_multi, names, options do |payload|
+        writes  = {}
+        ordered = instrument_multi :read_multi, names, options do |payload|
           if options[:force]
             reads = {}
           else
             reads = read_multi_entries(names, **options)
           end
 
-          writes  = {}
           ordered = names.index_with do |name|
             reads.fetch(name) { writes[name] = yield(name) }
           end
@@ -621,15 +613,20 @@ module ActiveSupport
           payload[:hits] = reads.keys
           payload[:super_operation] = :fetch_multi
 
-          write_multi(writes, options)
-
           ordered
         end
+
+        write_multi(writes, options)
+
+        ordered
       end
 
       # Writes the value to the cache with the key. The value must be supported
       # by the +coder+'s +dump+ and +load+ methods.
       #
+      # Returns +true+ if the write succeeded, +nil+ if there was an error talking
+      # to the cache backend, or +false+ if the write failed for another reason.
+      #
       # By default, cache entries larger than 1kB are compressed. Compression
       # allows more data to be stored in the same memory footprint, leading to
       # fewer cache evictions and higher hit rates.
@@ -662,10 +659,11 @@ module ActiveSupport
       # Other options will be handled by the specific cache store implementation.
       def write(name, value, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:write, name, options) do
+        instrument(:write, key, options) do
           entry = Entry.new(value, **options.merge(version: normalize_version(name, options)))
-          write_entry(normalize_key(name, options), entry, **options)
+          write_entry(key, entry, **options)
         end
       end
 
@@ -675,9 +673,10 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def delete(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:delete, name) do
-          delete_entry(normalize_key(name, options), **options)
+        instrument(:delete, key, options) do
+          delete_entry(key, **options)
         end
       end
 
@@ -691,7 +690,7 @@ module ActiveSupport
         options = merged_options(options)
         names.map! { |key| normalize_key(key, options) }
 
-        instrument_multi :delete_multi, names do
+        instrument_multi(:delete_multi, names, options) do
           delete_multi_entries(names, **options)
         end
       end
@@ -701,9 +700,10 @@ module ActiveSupport
       # Options are passed to the underlying cache implementation.
       def exist?(name, options = nil)
         options = merged_options(options)
+        key = normalize_key(name, options)
 
-        instrument(:exist?, name) do |payload|
-          entry = read_entry(normalize_key(name, options), **options, event: payload)
+        instrument(:exist?, key) do |payload|
+          entry = read_entry(key, **options, event: payload)
           (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
         end
       end
@@ -761,14 +761,6 @@ module ActiveSupport
       private
         def default_serializer
           case Cache.format_version
-          when 6.1
-            ActiveSupport.deprecator.warn <<~EOM
-              Support for `config.active_support.cache_format_version = 6.1` has been deprecated and will be removed in Rails 7.2.
-
-              Check the Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#new-activesupport-cache-serialization-format
-              for more information on how to upgrade.
-            EOM
-            Cache::SerializerWithFallback[:marshal_6_1]
           when 7.0
             Cache::SerializerWithFallback[:marshal_7_0]
           when 7.1
@@ -1016,7 +1008,7 @@ module ActiveSupport
               if multi
                 ": #{payload[:key].size} key(s) specified"
               elsif payload[:key]
-                ": #{normalize_key(payload[:key], options)}"
+                ": #{payload[:key]}"
               end
 
             debug_options = " (#{options.inspect})" unless options.blank?
@@ -1053,10 +1045,10 @@ module ActiveSupport
           entry.value
         end
 
-        def save_block_result_to_cache(name, options)
+        def save_block_result_to_cache(name, key, options)
           options = options.dup
 
-          result = instrument(:generate, name, options) do
+          result = instrument(:generate, key, options) do
             yield(name, WriteOptions.new(options))
           end
 

data/lib/active_support/callbacks.rb

@@ -150,7 +150,7 @@ module ActiveSupport
       def halted_callback_hook(filter, name)
       end
 
-      module Conditionals # :nodoc:
+      module Conditionals # :nodoc: all
         class Value
           def initialize(&block)
             @block = block
@@ -159,128 +159,76 @@ module ActiveSupport
         end
       end
 
-      module Filters
+      module Filters # :nodoc: all
         Environment = Struct.new(:target, :halted, :value)
 
         class Before
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config, filter, name)
+          def initialize(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, name)
-            else
-              halting(callback_sequence, user_callback, halted_lambda, filter, name)
-            end
+            @user_callback, @user_conditions, @halted_lambda, @filter, @name = user_callback, user_conditions, halted_lambda, filter, name
+            freeze
           end
+          attr_reader :user_callback, :user_conditions, :halted_lambda, :filter, :name
 
-          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
-              halted = env.halted
+          def call(env)
+            target = env.target
+            value  = env.value
+            halted = env.halted
 
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                result_lambda = -> { user_callback.call target, value }
-                env.halted = halted_lambda.call(target, result_lambda)
-                if env.halted
-                  target.send :halted_callback_hook, filter, name
-                end
+            if !halted && user_conditions.all? { |c| c.call(target, value) }
+              result_lambda = -> { user_callback.call target, value }
+              env.halted = halted_lambda.call(target, result_lambda)
+              if env.halted
+                target.send :halted_callback_hook, filter, name
               end
-
-              env
             end
-          end
-          private_class_method :halting_and_conditional
-
-          def self.halting(callback_sequence, user_callback, halted_lambda, filter, name)
-            callback_sequence.before do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
 
-              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, name
-                end
-              end
+            env
+          end
 
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.before(self)
           end
-          private_class_method :halting
         end
 
         class After
-          def self.build(callback_sequence, user_callback, user_conditions, chain_config)
-            if chain_config[:skip_after_callbacks_if_terminated]
-              if user_conditions.any?
-                halting_and_conditional(callback_sequence, user_callback, user_conditions)
-              else
-                halting(callback_sequence, user_callback)
-              end
-            else
-              if user_conditions.any?
-                conditional callback_sequence, user_callback, user_conditions
-              else
-                simple callback_sequence, user_callback
-              end
-            end
+          attr_reader :user_callback, :user_conditions, :halting
+          def initialize(user_callback, user_conditions, chain_config)
+            halting = chain_config[:skip_after_callbacks_if_terminated]
+            @user_callback, @user_conditions, @halting = user_callback, user_conditions, halting
+            freeze
           end
 
-          def self.halting_and_conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
-              halted = env.halted
-
-              if !halted && user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
+          def call(env)
+            target = env.target
+            value  = env.value
+            halted = env.halted
 
-              env
+            if (!halted || !@halting) && user_conditions.all? { |c| c.call(target, value) }
+              user_callback.call target, value
             end
-          end
-          private_class_method :halting_and_conditional
-
-          def self.halting(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              unless env.halted
-                user_callback.call env.target, env.value
-              end
 
-              env
-            end
+            env
           end
-          private_class_method :halting
-
-          def self.conditional(callback_sequence, user_callback, user_conditions)
-            callback_sequence.after do |env|
-              target = env.target
-              value  = env.value
 
-              if user_conditions.all? { |c| c.call(target, value) }
-                user_callback.call target, value
-              end
-
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.after(self)
           end
-          private_class_method :conditional
+        end
 
-          def self.simple(callback_sequence, user_callback)
-            callback_sequence.after do |env|
-              user_callback.call env.target, env.value
+        class Around
+          def initialize(user_callback, user_conditions)
+            @user_callback, @user_conditions = user_callback, user_conditions
+            freeze
+          end
 
-              env
-            end
+          def apply(callback_sequence)
+            callback_sequence.around(@user_callback, @user_conditions)
           end
-          private_class_method :simple
         end
       end
 
-      class Callback # :nodoc:#
+      class Callback # :nodoc:
         def self.build(chain, filter, kind, options)
           if filter.is_a?(String)
             raise ArgumentError, <<-MSG.squish
@@ -302,6 +250,8 @@ module ActiveSupport
           @filter  = filter
           @if      = check_conditionals(options[:if])
           @unless  = check_conditionals(options[:unless])
+
+          compiled
         end
 
         def merge_conditional_options(chain, if_option:, unless_option:)
@@ -329,19 +279,26 @@ module ActiveSupport
           end
         end
 
+        def compiled
+          @compiled ||=
+            begin
+              user_conditions = conditions_lambdas
+              user_callback = CallTemplate.build(@filter, self)
+
+              case kind
+              when :before
+                Filters::Before.new(user_callback.make_lambda, user_conditions, chain_config, @filter, name)
+              when :after
+                Filters::After.new(user_callback.make_lambda, user_conditions, chain_config)
+              when :around
+                Filters::Around.new(user_callback, user_conditions)
+              end
+            end
+        end
+
         # Wraps code with filter
         def apply(callback_sequence)
-          user_conditions = conditions_lambdas
-          user_callback = CallTemplate.build(@filter, self)
-
-          case kind
-          when :before
-            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
-            callback_sequence.around(user_callback, user_conditions)
-          end
+          compiled.apply(callback_sequence)
         end
 
         def current_scopes
@@ -368,14 +325,16 @@ module ActiveSupport
           end
 
           def conditions_lambdas
-            @if.map { |c| CallTemplate.build(c, self).make_lambda } +
+            conditions =
+              @if.map { |c| CallTemplate.build(c, self).make_lambda } +
               @unless.map { |c| CallTemplate.build(c, self).inverted_lambda }
+            conditions.empty? ? EMPTY_ARRAY : conditions
           end
       end
 
       # A future invocation of user-supplied code (either as a callback,
       # or a condition filter).
-      module CallTemplate # :nodoc:
+      module CallTemplate # :nodoc: all
         class MethodCall
           def initialize(method)
             @method_name = method
@@ -562,16 +521,18 @@ module ActiveSupport
           @call_template = call_template
           @user_conditions = user_conditions
 
-          @before = []
-          @after = []
+          @before = nil
+          @after = nil
         end
 
-        def before(&before)
+        def before(before)
+          @before ||= []
           @before.unshift(before)
           self
         end
 
-        def after(&after)
+        def after(after)
+          @after ||= []
           @after.push(after)
           self
         end
@@ -595,11 +556,11 @@ module ActiveSupport
         end
 
         def invoke_before(arg)
-          @before.each { |b| b.call(arg) }
+          @before&.each { |b| b.call(arg) }
         end
 
         def invoke_after(arg)
-          @after.each { |a| a.call(arg) }
+          @after&.each { |a| a.call(arg) }
         end
       end
 

data/lib/active_support/core_ext/array/conversions.rb

@@ -104,8 +104,6 @@ class Array
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s
-  deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
 
   # Returns a string that represents the array in XML by invoking +to_xml+
   # on each element. Active Record collections delegate their representation

data/lib/active_support/core_ext/class/subclasses.rb

@@ -1,43 +1,23 @@
 # frozen_string_literal: true
 
-require "active_support/ruby_features"
 require "active_support/descendants_tracker"
 
 class Class
-  if ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
-    # Returns an array with all classes that are < than its receiver.
-    #
-    #   class C; end
-    #   C.descendants # => []
-    #
-    #   class B < C; end
-    #   C.descendants # => [B]
-    #
-    #   class A < B; end
-    #   C.descendants # => [B, A]
-    #
-    #   class D < C; end
-    #   C.descendants # => [B, A, D]
-    def descendants
-      subclasses.concat(subclasses.flat_map(&:descendants))
-    end
-  else
-    def descendants
-      ObjectSpace.each_object(singleton_class).reject do |k|
-        k.singleton_class? || k == self
-      end
-    end
-
-    # Returns an array with the direct children of +self+.
-    #
-    #   class Foo; end
-    #   class Bar < Foo; end
-    #   class Baz < Bar; end
-    #
-    #   Foo.subclasses # => [Bar]
-    def subclasses
-      descendants.select { |descendant| descendant.superclass == self }
-    end
+  # Returns an array with all classes that are < than its receiver.
+  #
+  #   class C; end
+  #   C.descendants # => []
+  #
+  #   class B < C; end
+  #   C.descendants # => [B]
+  #
+  #   class A < B; end
+  #   C.descendants # => [B, A]
+  #
+  #   class D < C; end
+  #   C.descendants # => [B, A, D]
+  def descendants
+    subclasses.concat(subclasses.flat_map(&:descendants))
   end
 
   prepend ActiveSupport::DescendantsTracker::ReloadedClassesFiltering

data/lib/active_support/core_ext/date/blank.rb

@@ -11,4 +11,8 @@ class Date # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

data/lib/active_support/core_ext/date/conversions.rb

@@ -56,8 +56,6 @@ class Date
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s
-  deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect