activesupport 7.1.6 → 8.1.1

data/lib/active_support/callbacks.rb

@@ -4,9 +4,9 @@ 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"
-require "thread"
 
 module ActiveSupport
   # = Active Support \Callbacks
@@ -67,7 +67,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
@@ -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
@@ -540,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)
@@ -562,16 +522,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 +557,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
 
@@ -612,7 +574,7 @@ module ActiveSupport
           @name = name
           @config = {
             scope: [:kind],
-            terminator: default_terminator
+            terminator: DEFAULT_TERMINATOR
           }.merge!(config)
           @chain = []
           @all_callbacks = nil
@@ -700,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
@@ -710,6 +672,7 @@ module ActiveSupport
               terminate
             end
           end
+          DEFAULT_TERMINATOR = DefaultTerminator.new.freeze
       end
 
       module ClassMethods
@@ -943,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
 
@@ -964,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
 
@@ -973,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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module ClassAttribute # :nodoc:
+    class << self
+      def redefine(owner, name, namespaced_name, value)
+        if owner.singleton_class?
+          if owner.attached_object.is_a?(Module)
+            redefine_method(owner, namespaced_name, private: true) { value }
+          else
+            redefine_method(owner, name) { value }
+          end
+        end
+
+        redefine_method(owner.singleton_class, namespaced_name, private: true) { 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, namespaced_name, new_value)
+          end
+        end
+      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
+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/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/share_lock.rb

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

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/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