activesupport 7.2.2.1 → 8.0.5

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

@@ -22,6 +22,7 @@ class Time
       offset_format = time.formatted_offset(false)
       time.strftime("%a, %d %b %Y %H:%M:%S #{offset_format}")
     },
+    rfc2822: lambda { |time| time.rfc2822 },
     iso8601: lambda { |time| time.iso8601 }
   }
 
@@ -40,6 +41,7 @@ class Time
   #   time.to_fs(:long)         # => "January 18, 2007 06:10"
   #   time.to_fs(:long_ordinal) # => "January 18th, 2007 06:10"
   #   time.to_fs(:rfc822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
+  #   time.to_fs(:rfc2822)       # => "Thu, 18 Jan 2007 06:10:17 -0600"
   #   time.to_fs(:iso8601)      # => "2007-01-18T06:10:17-06:00"
   #
   # == Adding your own time formats to +to_fs+

data/lib/active_support/current_attributes.rb

@@ -108,15 +108,18 @@ module ActiveSupport
       # ==== Options
       #
       # * <tt>:default</tt> - The default value for the attributes. If the value
-      # is a proc or lambda, it will be called whenever an instance is
-      # constructed. Otherwise, the value will be duplicated with +#dup+.
-      # Default values are re-assigned when the attributes are reset.
+      #   is a proc or lambda, it will be called whenever an instance is
+      #   constructed. Otherwise, the value will be duplicated with +#dup+.
+      #   Default values are re-assigned when the attributes are reset.
       def attribute(*names, default: NOT_SET)
         invalid_attribute_names = names.map(&:to_sym) & INVALID_ATTRIBUTE_NAMES
         if invalid_attribute_names.any?
           raise ArgumentError, "Restricted attribute names: #{invalid_attribute_names.join(", ")}"
         end
 
+        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
+        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
+
         ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
             owner.define_cached_method(name, namespace: :current_attributes) do |batch|
@@ -134,9 +137,6 @@ module ActiveSupport
           end
         end
 
-        Delegation.generate(singleton_class, names, to: :instance, nilable: false, signature: "")
-        Delegation.generate(singleton_class, names.map { |n| "#{n}=" }, to: :instance, nilable: false, signature: "value")
-
         self.defaults = defaults.merge(names.index_with { default })
       end
 
@@ -185,9 +185,16 @@ module ActiveSupport
 
         def method_added(name)
           super
+
+          # We try to generate instance delegators early to not rely on method_missing.
           return if name == :initialize
+
+          # If the added method isn't public, we don't delegate it.
           return unless public_method_defined?(name)
-          return if respond_to?(name, true)
+
+          # If we already have a class method by that name, we don't override it.
+          return if singleton_class.method_defined?(name) || singleton_class.private_method_defined?(name)
+
           Delegation.generate(singleton_class, [name], to: :instance, as: self, nilable: false)
         end
     end

data/lib/active_support/delegation.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module ActiveSupport
   # Error generated by +delegate+ when a method is called on +nil+ and +allow_nil+
   # option is not used.
@@ -136,11 +134,11 @@ module ActiveSupport
               "def #{method_name}(#{definition})" <<
               "  _ = #{receiver}" <<
               "  _.#{method}(#{definition})" <<
-              "rescue NoMethodError => e" <<
+              "rescue ::NoMethodError => e" <<
               "  if _.nil? && e.name == :#{method}" <<
-              "    raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
+              "    ::Kernel.raise ::ActiveSupport::DelegationError.nil_target(:#{method_name}, :'#{receiver}')" <<
               "  else" <<
-              "    raise" <<
+              "    ::Kernel.raise" <<
               "  end" <<
               "end"
           end
@@ -153,49 +151,32 @@ module ActiveSupport
         target = target.to_s
         target = "self.#{target}" if RESERVED_METHOD_NAMES.include?(target) || target == "__target"
 
-        if allow_nil
-          owner.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, ...)
-              __target = #{target}
-              if __target.nil? && !nil.respond_to?(method)
-                nil
-              elsif __target.respond_to?(method)
-                __target.public_send(method, ...)
-              else
-                super
-              end
-            end
-          RUBY
+        nil_behavior = if allow_nil
+          "nil"
         else
-          owner.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.
+          "::Kernel.raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')"
+        end
 
-              return false if name == :marshal_dump || name == :_dump
-              #{target}.respond_to?(name) || super
-            end
+        owner.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.
 
-            def method_missing(method, ...)
-              __target = #{target}
-              if __target.nil? && !nil.respond_to?(method)
-                raise ::ActiveSupport::DelegationError.nil_target(method, :'#{target}')
-              elsif __target.respond_to?(method)
-                __target.public_send(method, ...)
-              else
-                super
-              end
+            return false if name == :marshal_dump || name == :_dump
+            #{target}.respond_to?(name) || super
+          end
+
+          def method_missing(method, ...)
+            __target = #{target}
+            if __target.nil? && !nil.respond_to?(method)
+              #{nil_behavior}
+            elsif __target.respond_to?(method)
+              __target.public_send(method, ...)
+            else
+              super
             end
-          RUBY
-        end
+          end
+        RUBY
       end
     end
   end

data/lib/active_support/dependencies.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
 require "active_support/dependencies/interlock"
 
 module ActiveSupport # :nodoc:

data/lib/active_support/deprecation/reporting.rb

@@ -139,7 +139,6 @@ module ActiveSupport
 
         def extract_callstack(callstack)
           return [] if callstack.empty?
-          return _extract_callstack(callstack) if callstack.first.is_a? String
 
           offending_line = callstack.find { |frame|
             # Code generated with `eval` doesn't have an `absolute_path`, e.g. templates.
@@ -150,24 +149,6 @@ module ActiveSupport
           [offending_line.path, offending_line.lineno, offending_line.label]
         end
 
-        def _extract_callstack(callstack)
-          ActiveSupport.deprecator.warn(<<~MESSAGE)
-            Passing the result of `caller` to ActiveSupport::Deprecation#warn is deprecated and will be removed in Rails 8.0.
-
-            Please pass the result of `caller_locations` instead.
-          MESSAGE
-
-          offending_line = callstack.find { |line| !ignored_callstack?(line) } || callstack.first
-
-          if offending_line
-            if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
-              md.captures
-            else
-              offending_line
-            end
-          end
-        end
-
         RAILS_GEM_ROOT = File.expand_path("../../../..", __dir__) + "/" # :nodoc:
         LIB_DIR = RbConfig::CONFIG["libdir"] # :nodoc:
 

data/lib/active_support/deprecation.rb

@@ -68,7 +68,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "8.0", gem_name = "Rails")
+    def initialize(deprecation_horizon = "8.1", gem_name = "Rails")
       self.gem_name = gem_name
       self.deprecation_horizon = deprecation_horizon
       # By default, warnings are not silenced and debugging is off.

data/lib/active_support/duration.rb

@@ -491,17 +491,21 @@ module ActiveSupport
         if @parts.empty?
           time.since(sign * value)
         else
-          @parts.inject(time) do |t, (type, number)|
-            if type == :seconds
-              t.since(sign * number)
-            elsif type == :minutes
-              t.since(sign * number * 60)
-            elsif type == :hours
-              t.since(sign * number * 3600)
-            else
-              t.advance(type => sign * number)
-            end
+          @parts.each do |type, number|
+            t = time
+            time =
+              if type == :seconds
+                t.since(sign * number)
+              elsif type == :minutes
+                t.since(sign * number * 60)
+              elsif type == :hours
+                t.since(sign * number * 3600)
+              else
+                t.advance(type => sign * number)
+              end
           end
+
+          time
         end
       end
 

data/lib/active_support/encrypted_configuration.rb

@@ -43,6 +43,12 @@ module ActiveSupport
       end
     end
 
+    class InvalidKeyError < RuntimeError
+      def initialize(content_path, key)
+        super "Key '#{key}' is invalid, it must respond to '#to_sym' from configuration in '#{content_path}'."
+      end
+    end
+
     delegate_missing_to :options
 
     def initialize(config_path:, key_path:, env_key:, raise_if_missing_key:)
@@ -61,7 +67,11 @@ module ActiveSupport
     end
 
     def validate! # :nodoc:
-      deserialize(read)
+      deserialize(read).each_key do |key|
+        key.to_sym
+      rescue NoMethodError
+        raise InvalidKeyError.new(content_path, key)
+      end
     end
 
     # Returns the decrypted content as a Hash with symbolized keys.
@@ -73,7 +83,7 @@ module ActiveSupport
     #   # => { some_secret: 123, some_namespace: { another_secret: 789 } }
     #
     def config
-      @config ||= deserialize(read).deep_symbolize_keys
+      @config ||= deep_symbolize_keys(deserialize(read))
     end
 
     def inspect # :nodoc:
@@ -81,6 +91,14 @@ module ActiveSupport
     end
 
     private
+      def deep_symbolize_keys(hash)
+        hash.deep_transform_keys do |key|
+          key.to_sym
+        rescue NoMethodError
+          raise InvalidKeyError.new(content_path, key)
+        end
+      end
+
       def deep_transform(hash)
         return hash unless hash.is_a?(Hash)
 

data/lib/active_support/error_reporter.rb

@@ -144,9 +144,9 @@ module ActiveSupport
     #
     def unexpected(error, severity: :warning, context: {}, source: DEFAULT_SOURCE)
       error = RuntimeError.new(error) if error.is_a?(String)
-      error.set_backtrace(caller(1)) if error.backtrace.nil?
 
       if @debug_mode
+        ensure_backtrace(error)
         raise UnexpectedError, "#{error.class.name}: #{error.message}", error.backtrace, cause: error
       else
         report(error, handled: true, severity: severity, context: context, source: source)
@@ -207,8 +207,15 @@ module ActiveSupport
     #
     #   Rails.error.report(error)
     #
+    # The +error+ argument must be an instance of Exception.
+    #
+    #   Rails.error.report(Exception.new("Something went wrong"))
+    #
+    # Otherwise you can use #unexpected to report an error which does accept a
+    # string argument.
     def report(error, handled: true, severity: handled ? :warning : :error, context: {}, source: DEFAULT_SOURCE)
       return if error.instance_variable_defined?(:@__rails_error_reported)
+      ensure_backtrace(error)
 
       unless SEVERITIES.include?(severity)
         raise ArgumentError, "severity must be one of #{SEVERITIES.map(&:inspect).join(", ")}, got: #{severity.inspect}"
@@ -231,11 +238,37 @@ module ActiveSupport
         end
       end
 
-      unless error.frozen?
-        error.instance_variable_set(:@__rails_error_reported, true)
+      while error
+        unless error.frozen?
+          error.instance_variable_set(:@__rails_error_reported, true)
+        end
+        error = error.cause
       end
 
       nil
     end
+
+    private
+      def ensure_backtrace(error)
+        return if error.frozen? # re-raising won't add a backtrace
+        return unless error.backtrace.nil?
+
+        begin
+          # We could use Exception#set_backtrace, but until Ruby 3.4
+          # it only support setting `Exception#backtrace` and not
+          # `Exception#backtrace_locations`. So raising the exception
+          # is a good way to build a real backtrace.
+          raise error
+        rescue error.class => error
+        end
+
+        count = 0
+        while error.backtrace_locations.first&.path == __FILE__
+          count += 1
+          error.backtrace_locations.shift
+        end
+
+        error.backtrace.shift(count)
+      end
   end
 end

data/lib/active_support/evented_file_update_checker.rb

@@ -3,7 +3,6 @@
 gem "listen", "~> 3.5"
 require "listen"
 
-require "set"
 require "pathname"
 require "concurrent/atomic/atomic_boolean"
 

data/lib/active_support/execution_wrapper.rb

@@ -89,7 +89,7 @@ module ActiveSupport
       instance = run!
       begin
         yield
-      rescue => error
+      rescue Exception => error
         error_reporter&.report(error, handled: false, source: source)
         raise
       ensure

data/lib/active_support/file_update_checker.rb

@@ -120,7 +120,7 @@ module ActiveSupport
       # healthy to consider this edge case because with mtimes in the future
       # reloading is not triggered.
       def max_mtime(paths)
-        time_now = Time.now
+        time_now = Time.at(0, Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond), :nanosecond)
         max_mtime = nil
 
         # Time comparisons are performed with #compare_without_coercion because

data/lib/active_support/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveSupport
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
-    TINY  = 2
-    PRE   = "1"
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 5
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_support/hash_with_indifferent_access.rb

@@ -262,9 +262,7 @@ module ActiveSupport
     #   hash[:a][:c] # => "c"
     #   dup[:a][:c]  # => "c"
     def dup
-      self.class.new(self).tap do |new_hash|
-        set_defaults(new_hash)
-      end
+      copy_defaults(self.class.new(self))
     end
 
     # This method has the same semantics of +update+, except it does not
@@ -313,10 +311,6 @@ module ActiveSupport
     end
     alias_method :without, :except
 
-    def stringify_keys!; self end
-    def deep_stringify_keys!; self end
-    def stringify_keys; dup end
-    def deep_stringify_keys; dup end
     undef :symbolize_keys!
     undef :deep_symbolize_keys!
     def symbolize_keys; to_hash.symbolize_keys! end
@@ -342,21 +336,26 @@ module ActiveSupport
     NOT_GIVEN = Object.new # :nodoc:
 
     def transform_keys(hash = NOT_GIVEN, &block)
-      return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
-      dup.tap { |h| h.transform_keys!(hash, &block) }
+      if NOT_GIVEN.equal?(hash)
+        if block_given?
+          self.class.new(super(&block))
+        else
+          to_enum(:transform_keys)
+        end
+      else
+        self.class.new(super)
+      end
     end
 
     def transform_keys!(hash = NOT_GIVEN, &block)
-      return to_enum(:transform_keys!) if NOT_GIVEN.equal?(hash) && !block_given?
-
-      if hash.nil?
-        super
-      elsif NOT_GIVEN.equal?(hash)
-        keys.each { |key| self[yield(key)] = delete(key) }
-      elsif block_given?
-        keys.each { |key| self[hash[key] || yield(key)] = delete(key) }
+      if NOT_GIVEN.equal?(hash)
+        if block_given?
+          replace(copy_defaults(transform_keys(&block)))
+        else
+          return to_enum(:transform_keys!)
+        end
       else
-        keys.each { |key| self[hash[key] || key] = delete(key) }
+        replace(copy_defaults(transform_keys(hash, &block)))
       end
 
       self
@@ -378,13 +377,9 @@ module ActiveSupport
 
     # Convert to a regular hash with string keys.
     def to_hash
-      _new_hash = Hash.new
-      set_defaults(_new_hash)
-
-      each do |key, value|
-        _new_hash[key] = convert_value(value, conversion: :to_hash)
-      end
-      _new_hash
+      copy = Hash[self]
+      copy.transform_values! { |v| convert_value_to_hash(v) }
+      copy_defaults(copy)
     end
 
     def to_proc
@@ -398,11 +393,7 @@ module ActiveSupport
 
       def convert_value(value, conversion: nil)
         if value.is_a? Hash
-          if conversion == :to_hash
-            value.to_hash
-          else
-            value.nested_under_indifferent_access
-          end
+          value.nested_under_indifferent_access
         elsif value.is_a?(Array)
           if conversion != :assignment || value.frozen?
             value = value.dup
@@ -413,12 +404,24 @@ module ActiveSupport
         end
       end
 
-      def set_defaults(target)
+      def convert_value_to_hash(value)
+        if value.is_a? Hash
+          value.to_hash
+        elsif value.is_a?(Array)
+          value.map { |e| convert_value_to_hash(e) }
+        else
+          value
+        end
+      end
+
+
+      def copy_defaults(target)
         if default_proc
           target.default_proc = default_proc.dup
         else
           target.default = default
         end
+        target
       end
 
       def update_with_single_argument(other_hash, block)

data/lib/active_support/i18n_railtie.rb

@@ -14,15 +14,18 @@ module I18n
 
     config.eager_load_namespaces << I18n
 
-    # Set the i18n configuration after initialization since a lot of
-    # configuration is still usually done in application initializers.
-    config.after_initialize do |app|
+    # Make sure i18n is ready before eager loading, in case any eager loaded
+    # code needs it.
+    config.before_eager_load do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
-    # Trigger i18n config before any eager loading has happened
-    # so it's ready if any classes require it when eager loaded.
-    config.before_eager_load do |app|
+    # i18n initialization needs to run after application initialization, since
+    # initializers may configure i18n.
+    #
+    # If the application eager loaded, this was done on before_eager_load. The
+    # hook is still OK, though, because initialize_i18n is idempotent.
+    config.after_initialize do |app|
       I18n::Railtie.initialize_i18n(app)
     end
 
@@ -49,7 +52,8 @@ module I18n
         when :load_path
           I18n.load_path += value
         when :raise_on_missing_translations
-          setup_raise_on_missing_translations_config(app)
+          strict = value == :strict
+          setup_raise_on_missing_translations_config(app, strict)
         else
           I18n.public_send("#{setting}=", value)
         end
@@ -62,8 +66,9 @@ module I18n
 
       if app.config.reloading_enabled?
         directories = watched_dirs_with_extensions(reloadable_paths)
-        reloader = app.config.file_watcher.new(I18n.load_path.dup, directories) do
-          I18n.load_path.keep_if { |p| File.exist?(p) }
+        root_load_paths = I18n.load_path.select { |path| path.to_s.start_with?(Rails.root.to_s) }
+        reloader = app.config.file_watcher.new(root_load_paths, directories) do
+          I18n.load_path.delete_if { |path| path.to_s.start_with?(Rails.root.to_s) && !File.exist?(path) }
           I18n.load_path |= reloadable_paths.flat_map(&:existent)
         end
 
@@ -71,17 +76,20 @@ module I18n
         app.reloader.to_run do
           reloader.execute_if_updated { require_unload_lock! }
         end
-        reloader.execute
       end
 
       @i18n_inited = true
     end
 
-    def self.setup_raise_on_missing_translations_config(app)
+    def self.setup_raise_on_missing_translations_config(app, strict)
       ActiveSupport.on_load(:action_view) do
         ActionView::Helpers::TranslationHelper.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations
       end
 
+      ActiveSupport.on_load(:active_model_translation) do
+        ActiveModel::Translation.raise_on_missing_translations = app.config.i18n.raise_on_missing_translations if strict
+      end
+
       if app.config.i18n.raise_on_missing_translations &&
           I18n.exception_handler.is_a?(I18n::ExceptionHandler) # Only override the i18n gem's default exception handler.
 

data/lib/active_support/inflector/inflections.rb

@@ -248,7 +248,8 @@ module ActiveSupport
 
       private
         def define_acronym_regex_patterns
-          @acronym_regex             = @acronyms.empty? ? /(?=a)b/ : /#{@acronyms.values.join("|")}/
+          sorted_acronyms = @acronyms.empty? ? [] : @acronyms.values.sort_by { |a| -a.length }
+          @acronym_regex             = sorted_acronyms.empty? ? /(?=a)b/ : /#{sorted_acronyms.join("|")}/
           @acronyms_camelize_regex   = /^(?:#{@acronym_regex}(?=\b|[A-Z_])|\w)/
           @acronyms_underscore_regex = /(?:(?<=([A-Za-z\d]))|\b)(#{@acronym_regex})(?=\b|[^a-z])/
         end

data/lib/active_support/inflector/methods.rb

@@ -119,7 +119,7 @@ module ActiveSupport
     # The capitalization of the first word can be turned off by setting the
     # +:capitalize+ option to false (default is true).
     #
-    # The trailing '_id' can be kept and capitalized by setting the
+    # The trailing '_id' can be kept by setting the
     # optional parameter +keep_id_suffix+ to true (default is false).
     #
     #   humanize('employee_salary')                  # => "Employee salary"
@@ -143,13 +143,13 @@ module ActiveSupport
         result.delete_suffix!(" id")
       end
 
-      result.gsub!(/([a-z\d]+)/i) do |match|
+      result.gsub!(/([[[:alpha:]]\d]+)/i) do |match|
         match.downcase!
         inflections.acronyms[match] || match
       end
 
       if capitalize
-        result.sub!(/\A\w/) do |match|
+        result.sub!(/\A[[:alpha:]]/) do |match|
           match.upcase!
           match
         end

data/lib/active_support/isolated_execution_state.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fiber"
-
 module ActiveSupport
   module IsolatedExecutionState # :nodoc:
     @isolation_level = nil
@@ -58,11 +56,13 @@ module ActiveSupport
         scope.current
       end
 
-      def share_with(other)
+      def share_with(other, except: [])
         # Action Controller streaming spawns a new thread and copy thread locals.
         # We do the same here for backward compatibility, but this is very much a hack
         # and streaming should be rethought.
-        context.active_support_execution_state = other.active_support_execution_state.dup
+        state = other.active_support_execution_state.dup
+        Array(except).each { |key| state.delete(key) }
+        context.active_support_execution_state = state
       end
 
       private

data/lib/active_support/json/decoding.rb

@@ -14,11 +14,13 @@ module ActiveSupport
     DATETIME_REGEX = /\A(?:\d{4}-\d{2}-\d{2}|\d{4}-\d{1,2}-\d{1,2}[T \t]+\d{1,2}:\d{2}:\d{2}(\.[0-9]*)?(([ \t]*)Z|[-+]\d{2}?(:\d{2})?)?)\z/
 
     class << self
-      # Parses a JSON string (JavaScript Object Notation) into a hash.
+      # Parses a JSON string (JavaScript Object Notation) into a Ruby object.
       # See http://www.json.org for more info.
       #
       #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   => {"team" => "rails", "players" => "36"}
+      #   # => {"team" => "rails", "players" => "36"}
+      #   ActiveSupport::JSON.decode("2.39")
+      #   # => 2.39
       def decode(json)
         data = ::JSON.parse(json, quirks_mode: true)