activesupport 7.2.4 → 8.0.0.beta1

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/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,10 +7,10 @@ module ActiveSupport
   end
 
   module VERSION
-    MAJOR = 7
-    MINOR = 2
-    TINY  = 4
-    PRE   = nil
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "beta1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

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
@@ -340,26 +342,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 +378,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 +395,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 +406,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.start_with?(Rails.root.to_s) }
+        reloader = app.config.file_watcher.new(root_load_paths, directories) do
+          I18n.load_path.delete_if { |p| p.start_with?(Rails.root.to_s) && !File.exist?(p) }
           I18n.load_path |= reloadable_paths.flat_map(&:existent)
         end
 
@@ -77,11 +82,15 @@ module I18n
       @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/methods.rb

@@ -143,13 +143,13 @@ module ActiveSupport
         result.delete_suffix!(" id")
       end
 
-      result.gsub!(/([[[:alpha:]]\d]+)/i) do |match|
+      result.gsub!(/([a-z\d]+)/i) do |match|
         match.downcase!
         inflections.acronyms[match] || match
       end
 
       if capitalize
-        result.sub!(/\A[[:alpha:]]/) do |match|
+        result.sub!(/\A\w/) do |match|
           match.upcase!
           match
         end

data/lib/active_support/isolated_execution_state.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "fiber"
 
 module ActiveSupport
   module IsolatedExecutionState # :nodoc:

data/lib/active_support/json/decoding.rb

@@ -18,9 +18,9 @@ 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)
+        data = ::JSON.parse(json, quirks_mode: true)
 
         if ActiveSupport.parse_json_times
           convert_dates_from(data)

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')
@@ -107,7 +89,7 @@ module ActiveSupport
 
           # Encode a "jsonified" Ruby data structure using the JSON gem
           def stringify(jsonified)
-            ::JSON.generate(jsonified)
+            ::JSON.generate(jsonified, quirks_mode: true, max_nesting: false)
           end
       end
 

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_pack/extensions.rb

@@ -4,7 +4,7 @@ require "bigdecimal"
 require "date"
 require "ipaddr"
 require "pathname"
-require "uri"
+require "uri/generic"
 require "msgpack/bigint"
 require "active_support/hash_with_indifferent_access"
 require "active_support/time"

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/number_helper/number_converter.rb

@@ -180,7 +180,7 @@ module ActiveSupport
           when Float, Rational
             number.to_d(0)
           when String
-            BigDecimal(number, exception: false) unless number.to_s.match?(/[de]/i)
+            BigDecimal(number, exception: false)
           else
             number.to_d rescue nil
           end

data/lib/active_support/number_helper/number_to_delimited_converter.rb

@@ -7,6 +7,8 @@ module ActiveSupport
     class NumberToDelimitedConverter < NumberConverter # :nodoc:
       self.validate_float = true
 
+      DEFAULT_DELIMITER_REGEX = /(\d)(?=(\d\d\d)+(?!\d))/
+
       def convert
         parts.join(options[:separator])
       end
@@ -14,29 +16,14 @@ module ActiveSupport
       private
         def parts
           left, right = number.to_s.split(".")
-          if delimiter_pattern
-            left.gsub!(delimiter_pattern) do |digit_to_delimit|
-              "#{digit_to_delimit}#{options[:delimiter]}"
-            end
-          else
-            left_parts = []
-            offset = left.size % 3
-            if offset > 0
-              left_parts << left[0, offset]
-            end
-
-            (left.size / 3).times do |i|
-              left_parts << left[offset + (i * 3), 3]
-            end
-
-            left = left_parts.join(options[:delimiter])
+          left.gsub!(delimiter_pattern) do |digit_to_delimit|
+            "#{digit_to_delimit}#{options[:delimiter]}"
           end
-
           [left, right].compact
         end
 
         def delimiter_pattern
-          options[:delimiter_pattern]
+          options.fetch(:delimiter_pattern, DEFAULT_DELIMITER_REGEX)
         end
     end
   end

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