activesupport 8.0.0 → 8.1.0

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

@@ -11,11 +11,12 @@ module ActiveSupport
         # This class wraps up local storage for middlewares. Only the middleware method should
         # construct them.
         class Middleware # :nodoc:
-          attr_reader :name, :local_cache_key
+          attr_reader :name
+          attr_accessor :cache
 
-          def initialize(name, local_cache_key)
+          def initialize(name, cache)
             @name = name
-            @local_cache_key = local_cache_key
+            @cache = cache
             @app = nil
           end
 
@@ -25,18 +26,17 @@ module ActiveSupport
           end
 
           def call(env)
-            LocalCacheRegistry.set_cache_for(local_cache_key, LocalStore.new)
+            cache.new_local_cache
             response = @app.call(env)
             response[2] = ::Rack::BodyProxy.new(response[2]) do
-              LocalCacheRegistry.set_cache_for(local_cache_key, nil)
+              cache.unset_local_cache
             end
             cleanup_on_body_close = true
             response
           rescue Rack::Utils::InvalidParameterError
             [400, {}, []]
           ensure
-            LocalCacheRegistry.set_cache_for(local_cache_key, nil) unless
-              cleanup_on_body_close
+            cache.unset_local_cache unless cleanup_on_body_close
           end
         end
       end

data/lib/active_support/cache.rb

@@ -35,6 +35,8 @@ module ActiveSupport
       :race_condition_ttl,
       :serializer,
       :skip_nil,
+      :raw,
+      :max_key_size,
     ]
 
     # Mapping of canonical option names to aliases that a store will recognize.
@@ -186,6 +188,12 @@ module ActiveSupport
     #   @last_mod_time = Time.now  # Invalidate the entire cache by changing namespace
     #
     class Store
+      # Default +ConnectionPool+ options
+      DEFAULT_POOL_OPTIONS = { size: 5, timeout: 5 }.freeze
+
+      # Keys are truncated with the Active Support digest if they exceed the limit.
+      MAX_KEY_SIZE = 250
+
       cattr_accessor :logger, instance_writer: true
       cattr_accessor :raise_on_invalid_cache_expiration_time, default: false
 
@@ -194,9 +202,6 @@ module ActiveSupport
 
       class << self
         private
-          DEFAULT_POOL_OPTIONS = { size: 5, timeout: 5 }.freeze
-          private_constant :DEFAULT_POOL_OPTIONS
-
           def retrieve_pool_options(options)
             if options.key?(:pool)
               pool_options = options.delete(:pool)
@@ -298,6 +303,9 @@ module ActiveSupport
         @options[:compress] = true unless @options.key?(:compress)
         @options[:compress_threshold] ||= DEFAULT_COMPRESS_LIMIT
 
+        @max_key_size = @options.delete(:max_key_size)
+        @max_key_size = MAX_KEY_SIZE if @max_key_size.nil? # allow 'false' as a value
+
         @coder = @options.delete(:coder) do
           legacy_serializer = Cache.format_version < 7.1 && !@options[:serializer]
           serializer = @options.delete(:serializer) || default_serializer
@@ -386,7 +394,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 minute.
+      #     # Set all values to expire after one second.
       #     cache = ActiveSupport::Cache::MemoryStore.new(expires_in: 1)
       #
       #     cache.write("foo", "original value")
@@ -556,7 +564,7 @@ module ActiveSupport
 
         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)))
+            memo[normalize_key(name, options)] = Entry.new(value, **options, version: normalize_version(name, options))
           end
 
           write_multi_entries entries, **options
@@ -658,13 +666,15 @@ module ActiveSupport
       #   version, the read will be treated as a cache miss. This feature is
       #   used to support recyclable cache keys.
       #
+      # * +:unless_exist+ - Prevents overwriting an existing cache entry.
+      #
       # 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, key, options) do
-          entry = Entry.new(value, **options.merge(version: normalize_version(name, options)))
+          entry = Entry.new(value, **options, version: normalize_version(name, options))
           write_entry(key, entry, **options)
         end
       end
@@ -741,6 +751,32 @@ module ActiveSupport
         raise NotImplementedError.new("#{self.class.name} does not support decrement")
       end
 
+      # Reads a counter that was set by #increment / #decrement.
+      #
+      #   cache.write_counter("foo", 1)
+      #   cache.read_counter("foo") # => 1
+      #   cache.increment("foo")
+      #   cache.read_counter("foo") # => 2
+      #
+      # Options are passed to the underlying cache implementation.
+      def read_counter(name, **options)
+        options = merged_options(options).merge(raw: true)
+        read(name, **options)&.to_i
+      end
+
+      # Writes a counter that can then be modified by #increment / #decrement.
+      #
+      #   cache.write_counter("foo", 1)
+      #   cache.read_counter("foo") # => 1
+      #   cache.increment("foo")
+      #   cache.read_counter("foo") # => 2
+      #
+      # Options are passed to the underlying cache implementation.
+      def write_counter(name, value, **options)
+        options = merged_options(options).merge(raw: true)
+        write(name, value.to_i, **options)
+      end
+
       # Cleans up the cache by removing expired entries.
       #
       # Options are passed to the underlying cache implementation.
@@ -760,6 +796,17 @@ module ActiveSupport
         raise NotImplementedError.new("#{self.class.name} does not support clear")
       end
 
+      # Get the current namespace
+      def namespace
+        @options[:namespace]
+      end
+
+      # Set the current namespace. Note, this will be ignored if custom
+      # options are passed to cache wills with a namespace key.
+      def namespace=(namespace)
+        @options[:namespace] = namespace
+      end
+
       private
         def default_serializer
           case Cache.format_version
@@ -926,16 +973,33 @@ module ActiveSupport
           options
         end
 
-        # Expands and namespaces the cache key.
+        # Expands, namespaces and truncates the cache key.
         # Raises an exception when the key is +nil+ or an empty string.
         # May be overridden by cache stores to do additional normalization.
         def normalize_key(key, options = nil)
+          key = expand_and_namespace_key(key, options)
+          truncate_key(key)
+        end
+
+        def expand_and_namespace_key(key, options = nil)
           str_key = expanded_key(key)
           raise(ArgumentError, "key cannot be blank") if !str_key || str_key.empty?
 
           namespace_key str_key, options
         end
 
+        def truncate_key(key)
+          if key && @max_key_size && key.bytesize > @max_key_size
+            suffix = ":hash:#{ActiveSupport::Digest.hexdigest(key)}"
+            truncate_at = @max_key_size - suffix.bytesize
+            key = key.byteslice(0, truncate_at)
+            key.scrub!("")
+            "#{key}#{suffix}"
+          else
+            key
+          end
+        end
+
         # Prefix the key with a namespace string:
         #
         #   namespace_key 'foo', namespace: 'cache'
@@ -1035,8 +1099,7 @@ 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
-              options[:expires_in] = race_ttl * 2
-              write_entry(key, entry, **options)
+              write_entry(key, entry, **options, expires_in: race_ttl * 2)
             else
               delete_entry(key, **options)
             end

data/lib/active_support/callbacks.rb

@@ -4,6 +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/module/redefine_method"
 require "active_support/core_ext/string/filters"
 require "active_support/core_ext/object/blank"
 
@@ -498,9 +499,10 @@ module ActiveSupport
           when Conditionals::Value
             ProcCall.new(filter)
           when ::Proc
-            if filter.arity > 1
+            case filter.arity
+            when 2
               InstanceExec2.new(filter)
-            elsif filter.arity > 0
+            when 1, -2
               InstanceExec1.new(filter)
             else
               InstanceExec0.new(filter)
@@ -572,7 +574,7 @@ module ActiveSupport
           @name = name
           @config = {
             scope: [:kind],
-            terminator: default_terminator
+            terminator: DEFAULT_TERMINATOR
           }.merge!(config)
           @chain = []
           @all_callbacks = nil
@@ -660,8 +662,8 @@ module ActiveSupport
             @chain.delete_if { |c| callback.duplicates?(c) }
           end
 
-          def default_terminator
-            Proc.new do |target, result_lambda|
+          class DefaultTerminator # :nodoc:
+            def call(target, result_lambda)
               terminate = true
               catch(:abort) do
                 result_lambda.call
@@ -670,6 +672,7 @@ module ActiveSupport
               terminate
             end
           end
+          DEFAULT_TERMINATOR = DefaultTerminator.new.freeze
       end
 
       module ClassMethods
@@ -903,12 +906,13 @@ module ActiveSupport
           names.each do |name|
             name = name.to_sym
 
-            ([self] + self.descendants).each do |target|
-              target.set_callbacks name, CallbackChain.new(name, options)
-            end
-
             module_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def _run_#{name}_callbacks(&block)
+              def _run_#{name}_callbacks
+                yield if block_given?
+              end
+              silence_redefinition_of_method(:_run_#{name}_callbacks)
+
+              def _run_#{name}_callbacks!(&block)
                 run_callbacks #{name.inspect}, &block
               end
 
@@ -924,6 +928,10 @@ module ActiveSupport
                 __callbacks[#{name.inspect}]
               end
             RUBY
+
+            ([self] + self.descendants).each do |target|
+              target.set_callbacks name, CallbackChain.new(name, options)
+            end
           end
         end
 
@@ -933,9 +941,17 @@ module ActiveSupport
           end
 
           def set_callbacks(name, callbacks) # :nodoc:
-            unless singleton_class.method_defined?(:__callbacks, false)
+            # HACK: We're making assumption on how `class_attribute` is implemented
+            # to save constantly duping the callback hash. If this desync with class_attribute
+            # we'll lose the optimization, but won't cause an actual behavior bug.
+            unless singleton_class.private_method_defined?(:__class_attr__callbacks, false)
               self.__callbacks = __callbacks.dup
             end
+            name = name.to_sym
+            callbacks_was = self.__callbacks[name.to_sym]
+            if (callbacks_was.nil? || callbacks_was.empty?) && !callbacks.empty?
+              alias_method("_run_#{name}_callbacks", "_run_#{name}_callbacks!")
+            end
             self.__callbacks[name.to_sym] = callbacks
             self.__callbacks
           end

data/lib/active_support/class_attribute.rb

@@ -3,23 +3,30 @@
 module ActiveSupport
   module ClassAttribute # :nodoc:
     class << self
-      def redefine(owner, name, value)
+      def redefine(owner, name, namespaced_name, value)
         if owner.singleton_class?
-          owner.redefine_method(name) { value }
-          owner.send(:public, name)
+          if owner.attached_object.is_a?(Module)
+            redefine_method(owner, namespaced_name, private: true) { value }
+          else
+            redefine_method(owner, name) { value }
+          end
         end
 
-        owner.redefine_singleton_method(name) { value }
-        owner.singleton_class.send(:public, name)
+        redefine_method(owner.singleton_class, namespaced_name, private: true) { value }
 
-        owner.redefine_singleton_method("#{name}=") do |new_value|
+        redefine_method(owner.singleton_class, "#{namespaced_name}=", private: true) do |new_value|
           if owner.equal?(self)
             value = new_value
           else
-            ::ActiveSupport::ClassAttribute.redefine(self, name, new_value)
+            ::ActiveSupport::ClassAttribute.redefine(self, name, namespaced_name, new_value)
           end
         end
-        owner.singleton_class.send(:public, "#{name}=")
+      end
+
+      def redefine_method(owner, name, private: false, &block)
+        owner.silence_redefinition_of_method(name)
+        owner.define_method(name, &block)
+        owner.send(:private, name) if private
       end
     end
   end

data/lib/active_support/concurrency/load_interlock_aware_monitor.rb

@@ -4,69 +4,15 @@ require "monitor"
 
 module ActiveSupport
   module Concurrency
-    module LoadInterlockAwareMonitorMixin # :nodoc:
-      EXCEPTION_NEVER = { Exception => :never }.freeze
-      EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
-      private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
-
-      # Enters an exclusive section, but allows dependency loading while blocked
-      def mon_enter
-        mon_try_enter ||
-          ActiveSupport::Dependencies.interlock.permit_concurrent_loads { super }
-      end
-
-      def synchronize(&block)
-        Thread.handle_interrupt(EXCEPTION_NEVER) do
-          mon_enter
-
-          begin
-            Thread.handle_interrupt(EXCEPTION_IMMEDIATE, &block)
-          ensure
-            mon_exit
-          end
-        end
-      end
-    end
     # A monitor that will permit dependency loading while blocked waiting for
     # the lock.
-    class LoadInterlockAwareMonitor < Monitor
-      include LoadInterlockAwareMonitorMixin
-    end
-
-    class ThreadLoadInterlockAwareMonitor # :nodoc:
-      prepend LoadInterlockAwareMonitorMixin
-
-      def initialize
-        @owner = nil
-        @count = 0
-        @mutex = Mutex.new
-      end
-
-      private
-        def mon_try_enter
-          if @owner != Thread.current
-            return false unless @mutex.try_lock
-            @owner = Thread.current
-          end
-          @count += 1
-        end
-
-        def mon_enter
-          @mutex.lock if @owner != Thread.current
-          @owner = Thread.current
-          @count += 1
-        end
-
-        def mon_exit
-          unless @owner == Thread.current
-            raise ThreadError, "current thread not owner"
-          end
-
-          @count -= 1
-          return unless @count == 0
-          @owner = nil
-          @mutex.unlock
-        end
-    end
+    LoadInterlockAwareMonitor = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+      "ActiveSupport::Concurrency::LoadInterlockAwareMonitor",
+      "::Monitor",
+      ActiveSupport.deprecator,
+      message: "ActiveSupport::Concurrency::LoadInterlockAwareMonitor is deprecated and will be " \
+               "removed in Rails 9.0. Use Monitor directly instead, as the loading interlock is " \
+               "no longer used."
+    )
   end
 end

data/lib/active_support/concurrency/thread_monitor.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Concurrency
+    class ThreadMonitor # :nodoc:
+      EXCEPTION_NEVER = { Exception => :never }.freeze
+      EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
+      private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
+
+      def initialize
+        @owner = nil
+        @count = 0
+        @mutex = Mutex.new
+      end
+
+      def synchronize(&block)
+        Thread.handle_interrupt(EXCEPTION_NEVER) do
+          mon_enter
+
+          begin
+            Thread.handle_interrupt(EXCEPTION_IMMEDIATE, &block)
+          ensure
+            mon_exit
+          end
+        end
+      end
+
+      private
+        def mon_try_enter
+          if @owner != Thread.current
+            return false unless @mutex.try_lock
+            @owner = Thread.current
+          end
+          @count += 1
+        end
+
+        def mon_enter
+          @mutex.lock if @owner != Thread.current
+          @owner = Thread.current
+          @count += 1
+        end
+
+        def mon_exit
+          unless @owner == Thread.current
+            raise ThreadError, "current thread not owner"
+          end
+
+          @count -= 1
+          return unless @count == 0
+          @owner = nil
+          @mutex.unlock
+        end
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -1,5 +1,11 @@
 # frozen_string_literal: true
 
+ActiveSupport.deprecator.warn <<~MSG
+  ActiveSupport::Configurable is deprecated without replacement, and will be removed in Rails 8.2.
+
+  You can emulate the previous behavior with `class_attribute`.
+MSG
+
 require "active_support/concern"
 require "active_support/ordered_options"
 
@@ -27,6 +33,19 @@ module ActiveSupport
     end
 
     module ClassMethods
+      # Reads and writes attributes from a configuration OrderedOptions.
+      #
+      #   require "active_support/configurable"
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #   end
+      #
+      #   User.config.allowed_access = true
+      #   User.config.level = 1
+      #
+      #   User.config.allowed_access # => true
+      #   User.config.level          # => 1
       def config
         @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
           superclass.config.inheritable_copy
@@ -36,6 +55,21 @@ module ActiveSupport
         end
       end
 
+      # Configure values from within the passed block.
+      #
+      #   require "active_support/configurable"
+      #
+      #   class User
+      #     include ActiveSupport::Configurable
+      #   end
+      #
+      #   User.allowed_access # => nil
+      #
+      #   User.configure do |config|
+      #     config.allowed_access = true
+      #   end
+      #
+      #   User.allowed_access # => true
       def configure
         yield config
       end

data/lib/active_support/continuous_integration.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  # Provides a DSL for declaring a continuous integration workflow that can be run either locally or in the cloud.
+  # Each step is timed, reports success/error, and is aggregated into a collective report that reports total runtime,
+  # as well as whether the entire run was successful or not.
+  #
+  # Example:
+  #
+  #   ActiveSupport::ContinuousIntegration.run do
+  #     step "Setup", "bin/setup --skip-server"
+  #     step "Style: Ruby", "bin/rubocop"
+  #     step "Security: Gem audit", "bin/bundler-audit"
+  #     step "Tests: Rails", "bin/rails test test:system"
+  #
+  #     if success?
+  #       step "Signoff: Ready for merge and deploy", "gh signoff"
+  #     else
+  #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+  #     end
+  #   end
+  #
+  # Starting with Rails 8.1, a default `bin/ci` and `config/ci.rb` file are created to provide out-of-the-box CI.
+  class ContinuousIntegration
+    COLORS = {
+      banner: "\033[1;32m",   # Green
+      title: "\033[1;35m",    # Purple
+      subtitle: "\033[1;90m", # Medium Gray
+      error: "\033[1;31m",    # Red
+      success: "\033[1;32m"   # Green
+    }
+
+    attr_reader :results
+
+    # Perform a CI run. Execute each step, show their results and runtime, and exit with a non-zero status if there are any failures.
+    #
+    # Pass an optional title, subtitle, and a block that declares the steps to be executed.
+    #
+    # Sets the CI environment variable to "true" to allow for conditional behavior in the app, like enabling eager loading and disabling logging.
+    #
+    # Example:
+    #
+    #   ActiveSupport::ContinuousIntegration.run do
+    #     step "Setup", "bin/setup --skip-server"
+    #     step "Style: Ruby", "bin/rubocop"
+    #     step "Security: Gem audit", "bin/bundler-audit"
+    #     step "Tests: Rails", "bin/rails test test:system"
+    #
+    #     if success?
+    #       step "Signoff: Ready for merge and deploy", "gh signoff"
+    #     else
+    #       failure "Skipping signoff; CI failed.", "Fix the issues and try again."
+    #     end
+    #   end
+    def self.run(title = "Continuous Integration", subtitle = "Running tests, style checks, and security audits", &block)
+      new.tap do |ci|
+        ENV["CI"] = "true"
+        ci.heading title, subtitle, padding: false
+        ci.report(title, &block)
+        abort unless ci.success?
+      end
+    end
+
+    def initialize
+      @results = []
+    end
+
+    # Declare a step with a title and a command. The command can either be given as a single string or as multiple
+    # strings that will be passed to `system` as individual arguments (and therefore correctly escaped for paths etc).
+    #
+    # Examples:
+    #
+    #   step "Setup", "bin/setup"
+    #   step "Single test", "bin/rails", "test", "--name", "test_that_is_one"
+    def step(title, *command)
+      heading title, command.join(" "), type: :title
+      report(title) { results << system(*command) }
+    end
+
+    # Returns true if all steps were successful.
+    def success?
+      results.all?
+    end
+
+    # Display an error heading with the title and optional subtitle to reflect that the run failed.
+    def failure(title, subtitle = nil)
+      heading title, subtitle, type: :error
+    end
+
+    # Display a colorized heading followed by an optional subtitle.
+    #
+    # Examples:
+    #
+    #   heading "Smoke Testing", "End-to-end tests verifying key functionality", padding: false
+    #   heading "Skipping video encoding tests", "Install FFmpeg to run these tests", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def heading(heading, subtitle = nil, type: :banner, padding: true)
+      echo "#{padding ? "\n\n" : ""}#{heading}", type: type
+      echo "#{subtitle}#{padding ? "\n" : ""}", type: :subtitle if subtitle
+    end
+
+    # Echo text to the terminal in the color corresponding to the type of the text.
+    #
+    # Examples:
+    #
+    #   echo "This is going to be green!", type: :success
+    #   echo "This is going to be red!", type: :error
+    #
+    # See ActiveSupport::ContinuousIntegration::COLORS for a complete list of options.
+    def echo(text, type:)
+      puts colorize(text, type)
+    end
+
+    # :nodoc:
+    def report(title, &block)
+      Signal.trap("INT") { abort colorize(:error, "\n❌ #{title} interrupted") }
+
+      ci = self.class.new
+      elapsed = timing { ci.instance_eval(&block) }
+
+      if ci.success?
+        echo "\n✅ #{title} passed in #{elapsed}", type: :success
+      else
+        echo "\n❌ #{title} failed in #{elapsed}", type: :error
+      end
+
+      results.concat ci.results
+    ensure
+      Signal.trap("INT", "-")
+    end
+
+    private
+      def timing
+        started_at = Time.now.to_f
+        yield
+        min, sec = (Time.now.to_f - started_at).divmod(60)
+        "#{"#{min}m" if min > 0}%.2fs" % sec
+      end
+
+      def colorize(text, type)
+        "#{COLORS.fetch(type)}#{text}\033[0m"
+      end
+  end
+end

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

@@ -16,11 +16,11 @@ class Array
   # ==== Options
   #
   # * <tt>:words_connector</tt> - The sign or word used to join all but the last
-  #   element in arrays with three or more elements (default: ", ").
+  #   element in arrays with three or more elements (default: <tt>", "</tt>).
   # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
-  #   in arrays with three or more elements (default: ", and ").
+  #   in arrays with three or more elements (default: <tt>", and "</tt>).
   # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
-  #   in arrays with two elements (default: " and ").
+  #   in arrays with two elements (default: <tt>" and "</tt>).
   # * <tt>:locale</tt> - If +i18n+ is available, you can set a locale and use
   #   the connector options defined on the 'support.array' namespace in the
   #   corresponding dictionary file.