activesupport 7.0.7.2 → 7.1.0.beta1

data/lib/active_support/callbacks.rb

@@ -9,7 +9,9 @@ require "active_support/core_ext/object/blank"
 require "thread"
 
 module ActiveSupport
-  # Callbacks are code hooks that are run at key points in an object's life cycle.
+  # = Active Support \Callbacks
+  #
+  # \Callbacks are code hooks that are run at key points in an object's life cycle.
   # The typical use case is to have a base class define a set of callbacks
   # relevant to the other functionality it supplies, so that subclasses can
   # install callbacks that enhance or modify the base functionality without
@@ -68,7 +70,7 @@ module ActiveSupport
       class_attribute :__callbacks, instance_writer: false, default: {}
     end
 
-    CALLBACK_FILTER_TYPES = [:before, :after, :around]
+    CALLBACK_FILTER_TYPES = [:before, :after, :around].freeze
 
     # Runs the callbacks for the given event.
     #
@@ -92,14 +94,15 @@ module ActiveSupport
     # callback can be as noisy as it likes -- but when control has passed
     # smoothly through and into the supplied block, we want as little evidence
     # as possible that we were here.
-    def run_callbacks(kind)
+    def run_callbacks(kind, type = nil)
       callbacks = __callbacks[kind.to_sym]
 
       if callbacks.empty?
         yield if block_given?
       else
         env = Filters::Environment.new(self, false, nil)
-        next_sequence = callbacks.compile
+
+        next_sequence = callbacks.compile(type)
 
         # Common case: no 'around' callbacks defined
         if next_sequence.final?
@@ -612,7 +615,8 @@ module ActiveSupport
             terminator: default_terminator
           }.merge!(config)
           @chain = []
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks = {}
           @mutex = Mutex.new
         end
 
@@ -621,32 +625,45 @@ module ActiveSupport
         def empty?;       @chain.empty?; end
 
         def insert(index, o)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.insert(index, o)
         end
 
         def delete(o)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.delete(o)
         end
 
         def clear
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks.clear
           @chain.clear
           self
         end
 
         def initialize_copy(other)
-          @callbacks = nil
+          @all_callbacks = nil
+          @single_callbacks = {}
           @chain     = other.chain.dup
           @mutex     = Mutex.new
         end
 
-        def compile
-          @callbacks || @mutex.synchronize do
-            final_sequence = CallbackSequence.new
-            @callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
-              callback.apply callback_sequence
+        def compile(type)
+          if type.nil?
+            @all_callbacks || @mutex.synchronize do
+              final_sequence = CallbackSequence.new
+              @all_callbacks ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
+                callback.apply(callback_sequence)
+              end
+            end
+          else
+            @single_callbacks[type] || @mutex.synchronize do
+              final_sequence = CallbackSequence.new
+              @single_callbacks[type] ||= @chain.reverse.inject(final_sequence) do |callback_sequence, callback|
+                type == callback.kind ? callback.apply(callback_sequence) : callback_sequence
+              end
             end
           end
         end
@@ -664,19 +681,22 @@ module ActiveSupport
 
         private
           def append_one(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             remove_duplicates(callback)
             @chain.push(callback)
           end
 
           def prepend_one(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             remove_duplicates(callback)
             @chain.unshift(callback)
           end
 
           def remove_duplicates(callback)
-            @callbacks = nil
+            @all_callbacks = nil
+            @single_callbacks.clear
             @chain.delete_if { |c| callback.duplicates?(c) }
           end
 
@@ -703,7 +723,7 @@ module ActiveSupport
         # This is used internally to append, prepend and skip callbacks to the
         # CallbackChain.
         def __update_callbacks(name) # :nodoc:
-          ([self] + self.descendants).reverse_each do |target|
+          self.descendants.prepend(self).reverse_each do |target|
             chain = target.get_callbacks name
             yield target, chain.dup
           end

data/lib/active_support/concern.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Active Support \Concern
+  #
   # A typical module looks like this:
   #
   #   module M
@@ -16,7 +18,7 @@ module ActiveSupport
   #     end
   #   end
   #
-  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # By using +ActiveSupport::Concern+ the above module could instead be
   # written as:
   #
   #   require "active_support/concern"
@@ -73,7 +75,7 @@ module ActiveSupport
   #   end
   #
   # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt>
-  # is the +Bar+ module, not the +Host+ class. With <tt>ActiveSupport::Concern</tt>,
+  # is the +Bar+ module, not the +Host+ class. With +ActiveSupport::Concern+,
   # module dependencies are properly resolved:
   #
   #   require "active_support/concern"

data/lib/active_support/concurrency/load_interlock_aware_monitor.rb

@@ -4,9 +4,7 @@ require "monitor"
 
 module ActiveSupport
   module Concurrency
-    # A monitor that will permit dependency loading while blocked waiting for
-    # the lock.
-    class LoadInterlockAwareMonitor < Monitor
+    module LoadInterlockAwareMonitorMixin # :nodoc:
       EXCEPTION_NEVER = { Exception => :never }.freeze
       EXCEPTION_IMMEDIATE = { Exception => :immediate }.freeze
       private_constant :EXCEPTION_NEVER, :EXCEPTION_IMMEDIATE
@@ -29,5 +27,46 @@ module ActiveSupport
         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
   end
 end

data/lib/active_support/concurrency/null_lock.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveSupport
+  module Concurrency
+    module NullLock # :nodoc:
+      extend self
+
+      def synchronize
+        yield
+      end
+    end
+  end
+end

data/lib/active_support/configurable.rb

@@ -4,6 +4,8 @@ require "active_support/concern"
 require "active_support/ordered_options"
 
 module ActiveSupport
+  # = Active Support \Configurable
+  #
   # Configurable provides a <tt>config</tt> method to store and retrieve
   # configuration options as an OrderedOptions.
   module Configurable
@@ -125,6 +127,14 @@ module ActiveSupport
         end
       end
       private :config_accessor
+
+      private
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @_config = nil
+          end
+        end
     end
 
     # Reads and writes attributes from a configuration OrderedOptions.

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

@@ -100,11 +100,12 @@ class Array
         collect(&:id).join(",")
       end
     else
-      to_default_s
+      to_s
     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/array.rb

@@ -3,7 +3,6 @@
 require "active_support/core_ext/array/wrap"
 require "active_support/core_ext/array/access"
 require "active_support/core_ext/array/conversions"
-require "active_support/core_ext/array/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/array/extract"
 require "active_support/core_ext/array/extract_options"
 require "active_support/core_ext/array/grouping"

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/ruby_features"
+require "active_support/descendants_tracker"
 
 class Class
   if ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
@@ -26,16 +27,18 @@ class Class
         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
   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 unless ActiveSupport::RubyFeatures::CLASS_SUBCLASSES
+  prepend ActiveSupport::DescendantsTracker::ReloadedClassesFiltering
 end

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

@@ -57,6 +57,7 @@ class Date
   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

data/lib/active_support/core_ext/date.rb

@@ -4,5 +4,4 @@ require "active_support/core_ext/date/acts_like"
 require "active_support/core_ext/date/blank"
 require "active_support/core_ext/date/calculations"
 require "active_support/core_ext/date/conversions"
-require "active_support/core_ext/date/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]
 require "active_support/core_ext/date/zones"

data/lib/active_support/core_ext/date_and_time/calculations.rb

@@ -157,6 +157,16 @@ module DateAndTime
     end
     alias :at_end_of_quarter :end_of_quarter
 
+    # Returns the quarter for a date/time.
+    #
+    #   Date.new(2010, 1, 31).quarter  # => 1
+    #   Date.new(2010, 4, 12).quarter  # => 2
+    #   Date.new(2010, 9, 15).quarter  # => 3
+    #   Date.new(2010, 12, 25).quarter # => 4
+    def quarter
+      (month / 3.0).ceil
+    end
+
     # Returns a new date/time at the beginning of the year.
     #
     #   today = Date.today # => Fri, 10 Jul 2015

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

@@ -36,11 +36,15 @@ class DateTime
     if formatter = ::Time::DATE_FORMATS[format]
       formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
     else
-      to_default_s
+      to_s
     end
   end
   alias_method :to_formatted_s, :to_fs
-  alias_method :to_default_s, :to_s if instance_methods(false).include?(:to_s)
+  if instance_methods(false).include?(:to_s)
+    alias_method :to_default_s, :to_s
+    deprecate to_default_s: :to_s, deprecator: ActiveSupport.deprecator
+  end
+
 
   # Returns a formatted string of the offset from UTC, or an alternative
   # string if the time zone is already UTC.

data/lib/active_support/core_ext/date_time.rb

@@ -5,4 +5,3 @@ require "active_support/core_ext/date_time/blank"
 require "active_support/core_ext/date_time/calculations"
 require "active_support/core_ext/date_time/compatibility"
 require "active_support/core_ext/date_time/conversions"
-require "active_support/core_ext/date_time/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]

data/lib/active_support/core_ext/digest/uuid.rb

@@ -10,8 +10,6 @@ module Digest
     OID_NAMESPACE  = "k\xA7\xB8\x12\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
     X500_NAMESPACE = "k\xA7\xB8\x14\x9D\xAD\x11\xD1\x80\xB4\x00\xC0O\xD40\xC8" # :nodoc:
 
-    mattr_accessor :use_rfc4122_namespaced_uuids, instance_accessor: false, default: false
-
     # Generates a v5 non-random UUID (Universally Unique IDentifier).
     #
     # Using OpenSSL::Digest::MD5 generates version 3 UUIDs; OpenSSL::Digest::SHA1 generates version 5 UUIDs.
@@ -58,19 +56,12 @@ module Digest
     def self.pack_uuid_namespace(namespace)
       if [DNS_NAMESPACE, OID_NAMESPACE, URL_NAMESPACE, X500_NAMESPACE].include?(namespace)
         namespace
-      elsif use_rfc4122_namespaced_uuids == true
+      else
         match_data = namespace.match(/\A(\h{8})-(\h{4})-(\h{4})-(\h{4})-(\h{4})(\h{8})\z/)
 
         raise ArgumentError, "Only UUIDs are valid namespace identifiers" unless match_data.present?
 
         match_data.captures.map { |s| s.to_i(16) }.pack("NnnnnN")
-      else
-        ActiveSupport::Deprecation.warn <<~WARNING.squish
-          Providing a namespace ID that is not one of the constants defined on Digest::UUID generates an incorrect UUID value according to RFC 4122.
-          To enable the correct behavior, set the Rails.application.config.active_support.use_rfc4122_namespaced_uuids configuration option to true.
-        WARNING
-
-        namespace
       end
     end
 

data/lib/active_support/core_ext/enumerable.rb

@@ -25,18 +25,6 @@ module Enumerable
   ActiveSupport::EnumerableCoreExt::SoleItemExpectedError = remove_const(:SoleItemExpectedError)
   singleton_class.prepend(ActiveSupport::EnumerableCoreExt::Constants)
 
-  # Enumerable#sum was added in Ruby 2.4, but it only works with Numeric elements
-  # when we omit an identity.
-
-  # :stopdoc:
-
-  # We can't use Refinements here because Refinements with Module which will be prepended
-  # doesn't work well https://bugs.ruby-lang.org/issues/13446
-  alias :_original_sum_with_required_identity :sum
-  private :_original_sum_with_required_identity
-
-  # :startdoc:
-
   # Calculates the minimum from the extracted elements.
   #
   #   payments = [Payment.new(5), Payment.new(15), Payment.new(10)]
@@ -53,50 +41,6 @@ module Enumerable
     map(&key).max
   end
 
-  # Calculates a sum from the elements.
-  #
-  #   payments.sum { |p| p.price * p.tax_rate }
-  #   payments.sum(&:price)
-  #
-  # The latter is a shortcut for:
-  #
-  #   payments.inject(0) { |sum, p| sum + p.price }
-  #
-  # It can also calculate the sum without the use of a block.
-  #
-  #   [5, 15, 10].sum # => 30
-  #   ['foo', 'bar'].sum('') # => "foobar"
-  #   [[1, 2], [3, 1, 5]].sum([]) # => [1, 2, 3, 1, 5]
-  #
-  # The default sum of an empty list is zero. You can override this default:
-  #
-  #   [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
-  def sum(identity = nil, &block)
-    if identity
-      _original_sum_with_required_identity(identity, &block)
-    elsif block_given?
-      map(&block).sum
-    else
-      first = true
-
-      reduce(nil) do |sum, value|
-        if first
-          first = false
-
-          unless value.is_a?(Numeric) || value.respond_to?(:coerce)
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Rails 7.0 has deprecated Enumerable.sum in favor of Ruby's native implementation available since 2.4.
-              Sum of non-numeric elements requires an initial argument.
-            MSG
-          end
-          value
-        else
-          sum + value
-        end
-      end || 0
-    end
-  end
-
   # Convert an enumerable to a hash, using the block result as the key and the
   # element as the value.
   #
@@ -289,38 +233,22 @@ end
 class Range # :nodoc:
   # Optimize range sum to use arithmetic progression if a block is not given and
   # we have a range of numeric values.
-  def sum(identity = nil)
+  def sum(initial_value = 0)
     if block_given? || !(first.is_a?(Integer) && last.is_a?(Integer))
       super
     else
       actual_last = exclude_end? ? (last - 1) : last
       if actual_last >= first
-        sum = identity || 0
+        sum = initial_value || 0
         sum + (actual_last - first + 1) * (actual_last + first) / 2
       else
-        identity || 0
+        initial_value || 0
       end
     end
   end
 end
 
-# Using Refinements here in order not to expose our internal method
-using Module.new {
-  refine Array do
-    alias :orig_sum :sum
-  end
-}
-
 class Array # :nodoc:
-  def sum(init = nil, &block)
-    if init.is_a?(Numeric) || first.is_a?(Numeric)
-      init ||= 0
-      orig_sum(init, &block)
-    else
-      super
-    end
-  end
-
   # Removes all blank elements from the +Array+ in place and returns self.
   # Uses Object#blank? for determining if an item is blank.
   #