activesupport 7.2.3 → 8.0.1

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)
@@ -209,6 +209,7 @@ module ActiveSupport
     #
     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,14 +232,34 @@ module ActiveSupport
         end
       end
 
-      while error
-        unless error.frozen?
-          error.instance_variable_set(:@__rails_error_reported, true)
-        end
-        error = error.cause
+      unless error.frozen?
+        error.instance_variable_set(:@__rails_error_reported, true)
       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 Exception => error
+      rescue => 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.at(0, Process.clock_gettime(Process::CLOCK_REALTIME, :nanosecond), :nanosecond)
+        time_now = Time.now
         max_mtime = nil
 
         # Time comparisons are performed with #compare_without_coercion because

data/lib/active_support/gem_version.rb

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

data/lib/active_support/hash_with_indifferent_access.rb

@@ -262,7 +262,9 @@ module ActiveSupport
     #   hash[:a][:c] # => "c"
     #   dup[:a][:c]  # => "c"
     def dup
-      copy_defaults(self.class.new(self))
+      self.class.new(self).tap do |new_hash|
+        set_defaults(new_hash)
+      end
     end
 
     # This method has the same semantics of +update+, except it does not
@@ -311,10 +313,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
@@ -340,26 +338,21 @@ module ActiveSupport
     NOT_GIVEN = Object.new # :nodoc:
 
     def transform_keys(hash = NOT_GIVEN, &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
+      return to_enum(:transform_keys) if NOT_GIVEN.equal?(hash) && !block_given?
+      dup.tap { |h| h.transform_keys!(hash, &block) }
     end
 
     def transform_keys!(hash = NOT_GIVEN, &block)
-      if NOT_GIVEN.equal?(hash)
-        if block_given?
-          replace(copy_defaults(transform_keys(&block)))
-        else
-          return to_enum(:transform_keys!)
-        end
+      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) }
       else
-        replace(copy_defaults(transform_keys(hash, &block)))
+        keys.each { |key| self[hash[key] || key] = delete(key) }
       end
 
       self
@@ -381,13 +374,10 @@ module ActiveSupport
 
     # Convert to a regular hash with string keys.
     def to_hash
-      _new_hash = Hash.new
-      copy_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) }
+      set_defaults(copy)
+      copy
     end
 
     def to_proc
@@ -401,11 +391,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
@@ -416,13 +402,23 @@ module ActiveSupport
         end
       end
 
-      def copy_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 set_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/isolated_execution_state.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "fiber"
-
 module ActiveSupport
   module IsolatedExecutionState # :nodoc:
     @isolation_level = nil

data/lib/active_support/json/decoding.rb

@@ -18,7 +18,7 @@ module ActiveSupport
       # See http://www.json.org for more info.
       #
       #   ActiveSupport::JSON.decode("{\"team\":\"rails\",\"players\":\"36\"}")
-      #   # => {"team" => "rails", "players" => "36"}
+      #   => {"team" => "rails", "players" => "36"}
       def decode(json)
         data = ::JSON.parse(json, quirks_mode: true)
 

data/lib/active_support/json/encoding.rb

@@ -13,30 +13,12 @@ module ActiveSupport
   end
 
   module JSON
+    # Dumps objects in JSON (JavaScript Object Notation).
+    # See http://www.json.org for more info.
+    #
+    #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
+    #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
     class << self
-      # Dumps objects in JSON (JavaScript Object Notation).
-      # See http://www.json.org for more info.
-      #
-      #   ActiveSupport::JSON.encode({ team: 'rails', players: '36' })
-      #   # => "{\"team\":\"rails\",\"players\":\"36\"}"
-      #
-      # Generates JSON that is safe to include in JavaScript as it escapes
-      # U+2028 (Line Separator) and U+2029 (Paragraph Separator):
-      #
-      #   ActiveSupport::JSON.encode({ key: "\u2028" })
-      #   # => "{\"key\":\"\\u2028\"}"
-      #
-      # By default, it also generates JSON that is safe to include in HTML, as
-      # it escapes <tt><</tt>, <tt>></tt>, and <tt>&</tt>:
-      #
-      #   ActiveSupport::JSON.encode({ key: "<>&" })
-      #   # => "{\"key\":\"\\u003c\\u003e\\u0026\"}"
-      #
-      # This can be changed with the +escape_html_entities+ option, or the
-      # global escape_html_entities_in_json configuration option.
-      #
-      #   ActiveSupport::JSON.encode({ key: "<>&" }, escape_html_entities: false)
-      #   # => "{\"key\":\"<>&\"}"
       def encode(value, options = nil)
         Encoding.json_encoder.new(options).encode(value)
       end
@@ -54,14 +36,14 @@ module ActiveSupport
         # Encode the given object into a JSON string
         def encode(value)
           unless options.empty?
-            value = value.as_json(options.dup)
+            value = value.as_json(options.dup.freeze)
           end
           json = stringify(jsonify(value))
 
           # Rails does more escaping than the JSON gem natively does (we
           # escape \u2028 and \u2029 and optionally >, <, & to work around
           # certain browser problems).
-          if Encoding.escape_html_entities_in_json
+          if @options.fetch(:escape_html_entities, Encoding.escape_html_entities_in_json)
             json.gsub!(">", '\u003e')
             json.gsub!("<", '\u003c')
             json.gsub!("&", '\u0026')

data/lib/active_support/lazy_load_hooks.rb

@@ -53,7 +53,7 @@ module ActiveSupport
     # loaded. If the component has already loaded, the block is executed
     # immediately.
     #
-    # ==== Options
+    # Options:
     #
     # * <tt>:yield</tt> - Yields the object that run_load_hooks to +block+.
     # * <tt>:run_once</tt> - Given +block+ will run only once.

data/lib/active_support/message_encryptors.rb

@@ -28,8 +28,8 @@ module ActiveSupport
     # <tt>transitional = false</tt>.
 
     ##
-    # :singleton-method: new
-    # :call-seq: new(&secret_generator)
+    # :method: initialize
+    # :call-seq: initialize(&secret_generator)
     #
     # Initializes a new instance. +secret_generator+ must accept a salt and a
     # +secret_length+ kwarg, and return a suitable secret (string) or secrets

data/lib/active_support/message_verifier.rb

@@ -154,8 +154,6 @@ module ActiveSupport
     #   not URL-safe. In other words, they can contain "+" and "/". If you want to
     #   generate URL-safe strings (in compliance with "Base 64 Encoding with URL
     #   and Filename Safe Alphabet" in RFC 4648), you can pass +true+.
-    #   Note that MessageVerifier will always accept both URL-safe and URL-unsafe
-    #   encoded messages, to allow a smooth transition between the two settings.
     #
     # [+:force_legacy_metadata_serializer+]
     #   Whether to use the legacy metadata serializer, which serializes the
@@ -320,13 +318,6 @@ module ActiveSupport
     end
 
     private
-      def decode(encoded, url_safe: @url_safe)
-        catch :invalid_message_format do
-          return super
-        end
-        super(encoded, url_safe: !url_safe)
-      end
-
       def sign_encoded(encoded)
         digest = generate_digest(encoded)
         encoded << SEPARATOR << digest

data/lib/active_support/message_verifiers.rb

@@ -28,8 +28,8 @@ module ActiveSupport
     # <tt>transitional = false</tt>.
 
     ##
-    # :singleton-method: new
-    # :call-seq: new(&secret_generator)
+    # :method: initialize
+    # :call-seq: initialize(&secret_generator)
     #
     # Initializes a new instance. +secret_generator+ must accept a salt, and
     # return a suitable secret (string). +secret_generator+ may also accept
@@ -59,9 +59,7 @@ module ActiveSupport
 
     ##
     # :method: rotate
-    # :call-seq:
-    #   rotate(**options)
-    #   rotate(&block)
+    # :call-seq: rotate(**options)
     #
     # Adds +options+ to the list of option sets. Messages will be signed using
     # the first set in the list. When verifying, however, each set will be

data/lib/active_support/messages/rotator.rb

@@ -15,11 +15,6 @@ module ActiveSupport
         fall_back_to build_rotation(*args, **options)
       end
 
-      def on_rotation(&on_rotation)
-        @on_rotation = on_rotation
-        self
-      end
-
       def fall_back_to(fallback)
         @rotations << fallback
         self

data/lib/active_support/multibyte/chars.rb

@@ -55,10 +55,7 @@ module ActiveSupport # :nodoc:
       # Creates a new Chars instance by wrapping _string_.
       def initialize(string)
         @wrapped_string = string
-        if string.encoding != Encoding::UTF_8
-          @wrapped_string = @wrapped_string.dup
-          @wrapped_string.force_encoding(Encoding::UTF_8)
-        end
+        @wrapped_string.force_encoding(Encoding::UTF_8) unless @wrapped_string.frozen?
       end
 
       # Forward all undefined methods to the wrapped string.

data/lib/active_support/notifications/fanout.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
-require "set"
 require "active_support/core_ext/object/try"
 
 module ActiveSupport

data/lib/active_support/number_helper.rb

@@ -1,6 +1,28 @@
 # frozen_string_literal: true
 
 module ActiveSupport
+  # = Number Helper
+  #
+  # Provides methods for formatting numbers into currencies, percentages,
+  # phone numbers, and more.
+  #
+  # Example usage in a class:
+  #   class Topic
+  #     include ActiveSupport::NumberHelper
+  #
+  #     def price
+  #       number_to_currency(@price)
+  #     end
+  #   end
+  #
+  # Example usage in a module:
+  #   require "active_support/number_helper"
+  #
+  #   module NumberFormatting
+  #     def format_price(price)
+  #       ActiveSupport::NumberHelper.number_to_currency(price)
+  #     end
+  #   end
   module NumberHelper
     extend ActiveSupport::Autoload
 

data/lib/active_support/railtie.rb

@@ -96,6 +96,10 @@ module ActiveSupport
       config.eager_load_namespaces << TZInfo
     end
 
+    initializer "active_support.to_time_preserves_timezone" do |app|
+      ActiveSupport.to_time_preserves_timezone = app.config.active_support.to_time_preserves_timezone
+    end
+
     # Sets the default week start
     # If assigned value is not a valid day symbol (e.g. :sunday, :monday, ...), an exception will be raised.
     initializer "active_support.initialize_beginning_of_week" do |app|

data/lib/active_support/tagged_logging.rb

@@ -113,6 +113,11 @@ module ActiveSupport
       end
     end
 
+    # Returns an `ActiveSupport::Logger` that has already been wrapped with tagged logging concern.
+    def self.logger(*args, **kwargs)
+      new ActiveSupport::Logger.new(*args, **kwargs)
+    end
+
     def self.new(logger)
       logger = logger.clone
 

data/lib/active_support/testing/assertions.rb

@@ -19,7 +19,7 @@ module ActiveSupport
       #
       #   assert_not foo, 'foo should be false'
       def assert_not(object, message = nil)
-        message ||= "Expected #{mu_pp(object)} to be nil or false"
+        message ||= -> { "Expected #{mu_pp(object)} to be nil or false" }
         assert !object, message
       end
 
@@ -118,9 +118,13 @@ module ActiveSupport
 
         expressions.zip(exps, before) do |(code, diff), exp, before_value|
           actual = exp.call
-          error  = "#{code.inspect} didn't change by #{diff}, but by #{actual - before_value}"
-          error  = "#{message}.\n#{error}" if message
-          assert_equal(before_value + diff, actual, error)
+          rich_message = -> do
+            code_string = code.respond_to?(:call) ? _callable_to_source_string(code) : code
+            error = "`#{code_string}` didn't change by #{diff}, but by #{actual - before_value}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert_equal(before_value + diff, actual, rich_message)
         end
 
         retval
@@ -195,22 +199,32 @@ module ActiveSupport
         retval = _assert_nothing_raised_or_warn("assert_changes", &block)
 
         unless from == UNTRACKED
-          error = "Expected change from #{from.inspect}, got #{before.inspect}"
-          error = "#{message}.\n#{error}" if message
-          assert from === before, error
+          rich_message = -> do
+            error = "Expected change from #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
         end
 
         after = exp.call
 
-        error = "#{expression.inspect} didn't change"
-        error = "#{error}. It was already #{to.inspect}" if before == to
-        error = "#{message}.\n#{error}" if message
-        refute_equal before, after, error
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` didn't change"
+          error = "#{error}. It was already #{to.inspect}" if before == to
+          error = "#{message}.\n#{error}" if message
+          error
+        end
+        refute_equal before, after, rich_message
 
         unless to == UNTRACKED
-          error = "Expected change to #{to.inspect}, got #{after.inspect}\n"
-          error = "#{message}.\n#{error}" if message
-          assert to === after, error
+          rich_message = -> do
+            error = "Expected change to #{to.inspect}, got #{after.inspect}\n"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert to === after, rich_message
         end
 
         retval
@@ -242,20 +256,27 @@ module ActiveSupport
         retval = _assert_nothing_raised_or_warn("assert_no_changes", &block)
 
         unless from == UNTRACKED
-          error = "Expected initial value of #{from.inspect}, got #{before.inspect}"
-          error = "#{message}.\n#{error}" if message
-          assert from === before, error
+          rich_message = -> do
+            error = "Expected initial value of #{from.inspect}, got #{before.inspect}"
+            error = "#{message}.\n#{error}" if message
+            error
+          end
+          assert from === before, rich_message
         end
 
         after = exp.call
 
-        error = "#{expression.inspect} changed"
-        error = "#{message}.\n#{error}" if message
+        rich_message = -> do
+          code_string = expression.respond_to?(:call) ? _callable_to_source_string(expression) : expression
+          error = "`#{code_string}` changed"
+          error = "#{message}.\n#{error}" if message
+          error
+        end
 
         if before.nil?
-          assert_nil after, error
+          assert_nil after, rich_message
         else
-          assert_equal before, after, error
+          assert_equal before, after, rich_message
         end
 
         retval
@@ -276,6 +297,43 @@ module ActiveSupport
 
           raise
         end
+
+        def _callable_to_source_string(callable)
+          if defined?(RubyVM::InstructionSequence) && callable.is_a?(Proc)
+            iseq = RubyVM::InstructionSequence.of(callable)
+            source =
+              if iseq.script_lines
+                iseq.script_lines.join("\n")
+              elsif File.readable?(iseq.absolute_path)
+                File.read(iseq.absolute_path)
+              end
+
+            return callable unless source
+
+            location = iseq.to_a[4][:code_location]
+            return callable unless location
+
+            lines = source.lines[(location[0] - 1)..(location[2] - 1)]
+            lines[-1] = lines[-1].byteslice(...location[3])
+            lines[0] = lines[0].byteslice(location[1]...)
+            source = lines.join.strip
+
+            # We ignore procs defined with do/end as they are likely multi-line anyway.
+            if source.start_with?("{")
+              source.delete_suffix!("}")
+              source.delete_prefix!("{")
+              source.strip!
+              # It won't read nice if the callable contains multiple
+              # lines, and it should be a rare occurrence anyway.
+              # Same if it takes arguments.
+              if !source.include?("\n") && !source.start_with?("|")
+                return source
+              end
+            end
+          end
+
+          callable
+        end
     end
   end
 end