activesupport 7.0.8.7 → 7.2.2.1

data/lib/active_support/core_ext/module/attribute_accessors.rb

@@ -43,6 +43,7 @@ class Module
   #
   #   module HairColors
   #     mattr_reader :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_reader(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -50,6 +51,7 @@ class Module
   #   end
   #
   #   Person.new.hair_colors # => [:brown, :black, :blonde, :red]
+  #   Person.new.hair_styles # => [:long, :short]
   def mattr_reader(*syms, instance_reader: true, instance_accessor: true, default: nil, location: nil)
     raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
     location ||= caller_locations(1, 1).first
@@ -107,6 +109,7 @@ class Module
   #
   #   module HairColors
   #     mattr_writer :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_writer(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -114,6 +117,7 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
   def mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil, location: nil)
     raise TypeError, "module attributes should be defined directly on class, not singleton" if singleton_class?
     location ||= caller_locations(1, 1).first
@@ -192,6 +196,7 @@ class Module
   #
   #   module HairColors
   #     mattr_accessor :hair_colors, default: [:brown, :black, :blonde, :red]
+  #     mattr_accessor(:hair_styles) { [:long, :short] }
   #   end
   #
   #   class Person
@@ -199,6 +204,7 @@ class Module
   #   end
   #
   #   Person.class_variable_get("@@hair_colors") # => [:brown, :black, :blonde, :red]
+  #   Person.class_variable_get("@@hair_styles") # => [:long, :short]
   def mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil, &blk)
     location = caller_locations(1, 1).first
     mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default, location: location, &blk)

data/lib/active_support/core_ext/module/attribute_accessors_per_thread.rb

@@ -42,14 +42,32 @@ class Module
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
-      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        def self.#{sym}
-          @__thread_mattr_#{sym} ||= "attr_\#{name}_#{sym}"
-          ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
-        end
-      EOS
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
+      if default.nil?
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+          end
+        EOS
+      else
+        default = default.dup.freeze unless default.frozen?
+        singleton_class.define_method("#{sym}_default_value") { default }
+
+        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+          def self.#{sym}
+            @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
+            value = ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}]
+
+            if value.nil? && !::ActiveSupport::IsolatedExecutionState.key?(@__thread_mattr_#{sym})
+              ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = #{sym}_default_value
+            else
+              value
+            end
+          end
+        EOS
+      end
 
       if instance_reader && instance_accessor
         class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -58,8 +76,6 @@ class Module
           end
         EOS
       end
-
-      ::ActiveSupport::IsolatedExecutionState["attr_#{name}_#{sym}"] = default unless default.nil?
     end
   end
   alias :thread_cattr_reader :thread_mattr_reader
@@ -82,15 +98,15 @@ class Module
   #   end
   #
   #   Current.new.user = "DHH" # => NoMethodError
-  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true, default: nil) # :nodoc:
+  def thread_mattr_writer(*syms, instance_writer: true, instance_accessor: true) # :nodoc:
     syms.each do |sym|
       raise NameError.new("invalid attribute name: #{sym}") unless /^[_A-Za-z]\w*$/.match?(sym)
 
-      # The following generated method concatenates `name` because we want it
-      # to work with inheritance via polymorphism.
+      # The following generated method concatenates `object_id` because we want
+      # subclasses to maintain independent values.
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)
-          @__thread_mattr_#{sym} ||= "attr_\#{name}_#{sym}"
+          @__thread_mattr_#{sym} ||= "attr_#{sym}_\#{object_id}"
           ::ActiveSupport::IsolatedExecutionState[@__thread_mattr_#{sym}] = obj
         end
       EOS
@@ -102,8 +118,6 @@ class Module
           end
         EOS
       end
-
-      public_send("#{sym}=", default) unless default.nil?
     end
   end
   alias :thread_cattr_writer :thread_mattr_writer
@@ -149,6 +163,10 @@ class Module
   #
   #   Current.new.user = "DHH"  # => NoMethodError
   #   Current.new.user          # => NoMethodError
+  #
+  # A default value may be specified using the +:default+ option. Because
+  # multiple threads can access the default value, non-frozen default values
+  # will be <tt>dup</tt>ed and frozen.
   def thread_mattr_accessor(*syms, instance_reader: true, instance_writer: true, instance_accessor: true, default: nil)
     thread_mattr_reader(*syms, instance_reader: instance_reader, instance_accessor: instance_accessor, default: default)
     thread_mattr_writer(*syms, instance_writer: instance_writer, instance_accessor: instance_accessor)

data/lib/active_support/core_ext/module/concerning.rb

@@ -3,7 +3,7 @@
 require "active_support/concern"
 
 class Module
-  # = Bite-sized separation of concerns
+  # == Bite-sized separation of concerns
   #
   # We often find ourselves with a medium-sized chunk of behavior that we'd
   # like to extract, but only mix in to a single class.
@@ -18,9 +18,9 @@ class Module
   # with a comment, as a least-bad alternative. Using modules in separate files
   # means tedious sifting to get a big-picture view.
   #
-  # = Dissatisfying ways to separate small concerns
+  # == Dissatisfying ways to separate small concerns
   #
-  # == Using comments:
+  # === Using comments:
   #
   #   class Todo < ApplicationRecord
   #     # Other todo implementation
@@ -37,7 +37,7 @@ class Module
   #       end
   #   end
   #
-  # == With an inline module:
+  # === With an inline module:
   #
   # Noisy syntax.
   #
@@ -61,7 +61,7 @@ class Module
   #     include EventTracking
   #   end
   #
-  # == Mix-in noise exiled to its own file:
+  # === Mix-in noise exiled to its own file:
   #
   # Once our chunk of behavior starts pushing the scroll-to-understand-it
   # boundary, we give in and move it to a separate file. At this size, the
@@ -75,7 +75,7 @@ class Module
   #     include TodoEventTracking
   #   end
   #
-  # = Introducing Module#concerning
+  # == Introducing Module#concerning
   #
   # By quieting the mix-in noise, we arrive at a natural, low-ceremony way to
   # separate bite-sized concerns.

data/lib/active_support/core_ext/module/delegation.rb

@@ -1,19 +1,8 @@
 # frozen_string_literal: true
 
-require "set"
-
 class Module
-  # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
-  # option is not used.
-  class DelegationError < NoMethodError; end
-
-  RUBY_RESERVED_KEYWORDS = %w(alias and BEGIN begin break case class def defined? do
-  else elsif END end ensure false for if in module next nil not or redo rescue retry
-  return self super then true undef unless until when while yield)
-  DELEGATION_RESERVED_KEYWORDS = %w(_ arg args block)
-  DELEGATION_RESERVED_METHOD_NAMES = Set.new(
-    RUBY_RESERVED_KEYWORDS + DELEGATION_RESERVED_KEYWORDS
-  ).freeze
+  require "active_support/delegation"
+  DelegationError = ActiveSupport::DelegationError # :nodoc:
 
   # Provides a +delegate+ class method to easily expose contained objects'
   # public methods as your own.
@@ -21,7 +10,7 @@ class Module
   # ==== Options
   # * <tt>:to</tt> - Specifies the target object name as a symbol or string
   # * <tt>:prefix</tt> - Prefixes the new method with the target name or a custom prefix
-  # * <tt>:allow_nil</tt> - If set to true, prevents a +Module::DelegationError+
+  # * <tt>:allow_nil</tt> - If set to true, prevents a +ActiveSupport::DelegationError+
   #   from being raised
   # * <tt>:private</tt> - If set to true, changes method visibility to private
   #
@@ -132,7 +121,7 @@ class Module
   #   User.new.age # => 2
   #
   # If the target is +nil+ and does not respond to the delegated method a
-  # +Module::DelegationError+ is raised. If you wish to instead return +nil+,
+  # +ActiveSupport::DelegationError+ is raised. If you wish to instead return +nil+,
   # use the <tt>:allow_nil</tt> option.
   #
   #   class User < ActiveRecord::Base
@@ -141,7 +130,7 @@ class Module
   #   end
   #
   #   User.new.age
-  #   # => Module::DelegationError: User#age delegated to profile.age, but profile is nil
+  #   # => ActiveSupport::DelegationError: User#age delegated to profile.age, but profile is nil
   #
   # But if not having a profile yet is fine and should not be an error
   # condition:
@@ -169,75 +158,15 @@ class Module
   #
   # The target method must be public, otherwise it will raise +NoMethodError+.
   def delegate(*methods, to: nil, prefix: nil, allow_nil: nil, private: nil)
-    unless to
-      raise ArgumentError, "Delegation needs a target. Supply a keyword argument 'to' (e.g. delegate :hello, to: :greeter)."
-    end
-
-    if prefix == true && /^[^a-z_]/.match?(to)
-      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
-    end
-
-    method_prefix = \
-      if prefix
-        "#{prefix == true ? to : prefix}_"
-      else
-        ""
-      end
-
-    location = caller_locations(1, 1).first
-    file, line = location.path, location.lineno
-
-    to = to.to_s
-    to = "self.#{to}" if DELEGATION_RESERVED_METHOD_NAMES.include?(to)
-
-    method_def = []
-    method_names = []
-
-    methods.map do |method|
-      method_name = prefix ? "#{method_prefix}#{method}" : method
-      method_names << method_name.to_sym
-
-      # Attribute writer methods only accept one argument. Makes sure []=
-      # methods still accept two arguments.
-      definition = /[^\]]=\z/.match?(method) ? "arg" : "..."
-
-      # The following generated method calls the target exactly once, storing
-      # the returned value in a dummy variable.
-      #
-      # Reason is twofold: On one hand doing less calls is in general better.
-      # On the other hand it could be that the target has side-effects,
-      # whereas conceptually, from the user point of view, the delegator should
-      # be doing one call.
-      if allow_nil
-        method = method.to_s
-
-        method_def <<
-          "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
-          "  if !_.nil? || nil.respond_to?(:#{method})" <<
-          "    _.#{method}(#{definition})" <<
-          "  end" <<
-          "end"
-      else
-        method = method.to_s
-        method_name = method_name.to_s
-
-        method_def <<
-          "def #{method_name}(#{definition})" <<
-          "  _ = #{to}" <<
-          "  _.#{method}(#{definition})" <<
-          "rescue NoMethodError => e" <<
-          "  if _.nil? && e.name == :#{method}" <<
-          %(   raise DelegationError, "#{self}##{method_name} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}") <<
-          "  else" <<
-          "    raise" <<
-          "  end" <<
-          "end"
-      end
-    end
-    module_eval(method_def.join(";"), file, line)
-    private(*method_names) if private
-    method_names
+    ::ActiveSupport::Delegation.generate(
+      self,
+      methods,
+      location: caller_locations(1, 1).first,
+      to: to,
+      prefix: prefix,
+      allow_nil: allow_nil,
+      private: private,
+    )
   end
 
   # When building decorators, a common pattern may emerge:
@@ -279,7 +208,7 @@ class Module
   # variables, methods, constants, etc.
   #
   # The delegated method must be public on the target, otherwise it will
-  # raise +DelegationError+. If you wish to instead return +nil+,
+  # raise +ActiveSupport::DelegationError+. If you wish to instead return +nil+,
   # use the <tt>:allow_nil</tt> option.
   #
   # The <tt>marshal_dump</tt> and <tt>_dump</tt> methods are exempt from
@@ -287,38 +216,10 @@ class Module
   # <tt>Marshal.dump(object)</tt>, should the delegation target method
   # of <tt>object</tt> add or remove instance variables.
   def delegate_missing_to(target, allow_nil: nil)
-    target = target.to_s
-    target = "self.#{target}" if DELEGATION_RESERVED_METHOD_NAMES.include?(target)
-
-    module_eval <<-RUBY, __FILE__, __LINE__ + 1
-      def respond_to_missing?(name, include_private = false)
-        # It may look like an oversight, but we deliberately do not pass
-        # +include_private+, because they do not get delegated.
-
-        return false if name == :marshal_dump || name == :_dump
-        #{target}.respond_to?(name) || super
-      end
-
-      def method_missing(method, *args, &block)
-        if #{target}.respond_to?(method)
-          #{target}.public_send(method, *args, &block)
-        else
-          begin
-            super
-          rescue NoMethodError
-            if #{target}.nil?
-              if #{allow_nil == true}
-                nil
-              else
-                raise DelegationError, "\#{method} delegated to #{target}, but #{target} is nil"
-              end
-            else
-              raise
-            end
-          end
-        end
-      end
-      ruby2_keywords(:method_missing)
-    RUBY
+    ::ActiveSupport::Delegation.generate_method_missing(
+      self,
+      target,
+      allow_nil: allow_nil,
+    )
   end
 end

data/lib/active_support/core_ext/module/deprecation.rb

@@ -1,17 +1,12 @@
 # frozen_string_literal: true
 
 class Module
-  #   deprecate :foo
-  #   deprecate bar: 'message'
-  #   deprecate :foo, :bar, baz: 'warning!', qux: 'gone!'
+  #   deprecate :foo, deprecator: MyLib.deprecator
+  #   deprecate :foo, bar: "warning!", deprecator: MyLib.deprecator
   #
-  # You can also use custom deprecator instance:
-  #
-  #   deprecate :foo, deprecator: MyLib::Deprecator.new
-  #   deprecate :foo, bar: "warning!", deprecator: MyLib::Deprecator.new
-  #
-  # \Custom deprecators must respond to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt>
-  # method where you can implement your custom warning behavior.
+  # A deprecator is typically an instance of ActiveSupport::Deprecation, but you can also pass any object that responds
+  # to <tt>deprecation_warning(deprecated_method_name, message, caller_backtrace)</tt> where you can implement your
+  # custom warning behavior.
   #
   #   class MyLib::Deprecator
   #     def deprecation_warning(deprecated_method_name, message, caller_backtrace = nil)
@@ -19,7 +14,12 @@ class Module
   #       Kernel.warn message
   #     end
   #   end
-  def deprecate(*method_names)
-    ActiveSupport::Deprecation.deprecate_methods(self, *method_names)
+  def deprecate(*method_names, deprecator:, **options)
+    if deprecator.is_a?(ActiveSupport::Deprecation)
+      deprecator.deprecate_methods(self, *method_names, **options)
+    elsif deprecator
+      # we just need any instance to call deprecate_methods, but the deprecation will be emitted by deprecator
+      ActiveSupport.deprecator.deprecate_methods(self, *method_names, **options, deprecator: deprecator)
+    end
   end
 end

data/lib/active_support/core_ext/module/introspection.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/string/filters"
 require "active_support/inflector"
 
 class Module

data/lib/active_support/core_ext/numeric/bytes.rb

@@ -7,6 +7,7 @@ class Numeric
   TERABYTE = GIGABYTE * 1024
   PETABYTE = TERABYTE * 1024
   EXABYTE  = PETABYTE * 1024
+  ZETTABYTE = EXABYTE * 1024
 
   # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
   #
@@ -63,4 +64,12 @@ class Numeric
     self * EXABYTE
   end
   alias :exabyte :exabytes
+
+  # Returns the number of bytes equivalent to the zettabytes provided.
+  #
+  #   2.zettabytes # => 2_361_183_241_434_822_606_848
+  def zettabytes
+    self * ZETTABYTE
+  end
+  alias :zettabyte :zettabytes
 end

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

@@ -5,6 +5,8 @@ require "active_support/number_helper"
 
 module ActiveSupport
   module NumericWithFormat
+    # \Numeric With Format
+    #
     # Provides options for converting numbers into formatted strings.
     # Options are provided for phone numbers, currency, percentage,
     # precision, positional notation, file size, and pretty printing.
@@ -138,6 +140,6 @@ module ActiveSupport
   end
 end
 
-Integer.prepend ActiveSupport::NumericWithFormat
-Float.prepend ActiveSupport::NumericWithFormat
-BigDecimal.prepend ActiveSupport::NumericWithFormat
+Integer.include ActiveSupport::NumericWithFormat
+Float.include ActiveSupport::NumericWithFormat
+BigDecimal.include ActiveSupport::NumericWithFormat

data/lib/active_support/core_ext/numeric.rb

@@ -3,4 +3,3 @@
 require "active_support/core_ext/numeric/bytes"
 require "active_support/core_ext/numeric/time"
 require "active_support/core_ext/numeric/conversions"
-require "active_support/core_ext/numeric/deprecated_conversions" unless ENV["RAILS_DISABLE_DEPRECATED_TO_S_CONVERSION"]

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

@@ -16,7 +16,7 @@ class Object
   #
   # @return [true, false]
   def blank?
-    respond_to?(:empty?) ? !!empty? : !self
+    respond_to?(:empty?) ? !!empty? : false
   end
 
   # An object is present if it's not blank.
@@ -56,6 +56,10 @@ class NilClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class FalseClass
@@ -67,6 +71,10 @@ class FalseClass
   def blank?
     true
   end
+
+  def present? # :nodoc:
+    false
+  end
 end
 
 class TrueClass
@@ -78,6 +86,10 @@ class TrueClass
   def blank?
     false
   end
+
+  def present? # :nodoc:
+    true
+  end
 end
 
 class Array
@@ -88,6 +100,10 @@ class Array
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class Hash
@@ -98,6 +114,22 @@ class Hash
   #
   # @return [true, false]
   alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
+end
+
+class Symbol
+  # A Symbol is blank if it's empty:
+  #
+  #   :''.blank?     # => true
+  #   :symbol.blank? # => false
+  alias_method :blank?, :empty?
+
+  def present? # :nodoc:
+    !empty?
+  end
 end
 
 class String
@@ -129,6 +161,10 @@ class String
         ENCODED_BLANKS[self.encoding].match?(self)
       end
   end
+
+  def present? # :nodoc:
+    !blank?
+  end
 end
 
 class Numeric # :nodoc:
@@ -141,6 +177,10 @@ class Numeric # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end
 
 class Time # :nodoc:
@@ -152,4 +192,8 @@ class Time # :nodoc:
   def blank?
     false
   end
+
+  def present?
+    true
+  end
 end

data/lib/active_support/core_ext/object/deep_dup.rb

@@ -53,3 +53,19 @@ class Hash
     hash
   end
 end
+
+class Module
+  # Returns a copy of module or class if it's anonymous. If it's
+  # named, returns +self+.
+  #
+  #   Object.deep_dup == Object # => true
+  #   klass = Class.new
+  #   klass.deep_dup == klass # => false
+  def deep_dup
+    if name.nil?
+      super
+    else
+      self
+    end
+  end
+end

data/lib/active_support/core_ext/object/inclusion.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
 class Object
-  # Returns true if this object is included in the argument. Argument must be
-  # any object which responds to +#include?+. Usage:
+  # Returns true if this object is included in the argument.
+  #
+  # When argument is a +Range+, +#cover?+ is used to properly handle inclusion
+  # check within open ranges. Otherwise, argument must be any object which responds
+  # to +#include?+. Usage:
   #
   #   characters = ["Konata", "Kagami", "Tsukasa"]
   #   "Konata".in?(characters) # => true
   #
-  # This will throw an +ArgumentError+ if the argument doesn't respond
-  # to +#include?+.
+  # For non +Range+ arguments, this will throw an +ArgumentError+ if the argument
+  # doesn't respond to +#include?+.
   def in?(another_object)
-    another_object.include?(self)
+    case another_object
+    when Range
+      another_object.cover?(self)
+    else
+      another_object.include?(self)
+    end
   rescue NoMethodError
     raise ArgumentError.new("The parameter passed to #in? must respond to #include?")
   end

data/lib/active_support/core_ext/object/instance_variables.rb

@@ -12,7 +12,9 @@ class Object
   #
   #   C.new(0, 1).instance_values # => {"x" => 0, "y" => 1}
   def instance_values
-    Hash[instance_variables.map { |name| [name[1..-1], instance_variable_get(name)] }]
+    instance_variables.to_h do |ivar|
+      [ivar[1..-1].freeze, instance_variable_get(ivar)]
+    end
   end
 
   # Returns an array of instance variable names as strings including "@".
@@ -25,6 +27,6 @@ class Object
   #
   #   C.new(0, 1).instance_variable_names # => ["@y", "@x"]
   def instance_variable_names
-    instance_variables.map(&:to_s)
+    instance_variables.map(&:name)
   end
 end