activesupport 7.2.3 → 8.0.0.beta1

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  = 3
-    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/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,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/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,36 @@ module ActiveSupport
 
           raise
         end
+
+        def _callable_to_source_string(callable)
+          if defined?(RubyVM::AbstractSyntaxTree) && callable.is_a?(Proc)
+            ast = begin
+              RubyVM::AbstractSyntaxTree.of(callable, keep_script_lines: true)
+            rescue SystemCallError
+              # Failed to get the source somehow
+              return callable
+            end
+            return callable unless ast
+
+            source = ast.source
+            source.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 occurence anyway.
+              # Same if it takes arguments.
+              if !source.include?("\n") && !source.start_with?("|")
+                return source
+              end
+            end
+          end
+
+          callable
+        end
     end
   end
 end

data/lib/active_support/testing/isolation.rb

@@ -5,8 +5,6 @@ require "active_support/testing/parallelize_executor"
 module ActiveSupport
   module Testing
     module Isolation
-      require "thread"
-
       SubprocessCrashed = Class.new(StandardError)
 
       def self.included(klass) # :nodoc:

data/lib/active_support/testing/parallelization/server.rb

@@ -14,7 +14,6 @@ module ActiveSupport
         def initialize
           @queue = Queue.new
           @active_workers = Concurrent::Map.new
-          @worker_pids = Concurrent::Map.new
           @in_flight = Concurrent::Map.new
         end
 
@@ -41,24 +40,12 @@ module ActiveSupport
           end
         end
 
-        def start_worker(worker_id, worker_pid)
+        def start_worker(worker_id)
           @active_workers[worker_id] = true
-          @worker_pids[worker_id] = worker_pid
         end
 
-        def stop_worker(worker_id, worker_pid)
+        def stop_worker(worker_id)
           @active_workers.delete(worker_id)
-          @worker_pids.delete(worker_id)
-        end
-
-        def remove_dead_workers(dead_pids)
-          dead_pids.each do |dead_pid|
-            worker_id = @worker_pids.key(dead_pid)
-            if worker_id
-              @active_workers.delete(worker_id)
-              @worker_pids.delete(worker_id)
-            end
-          end
         end
 
         def active_workers?

data/lib/active_support/testing/parallelization/worker.rb

@@ -18,7 +18,7 @@ module ActiveSupport
             DRb.stop_service
 
             @queue = DRbObject.new_with_uri(@url)
-            @queue.start_worker(@id, Process.pid)
+            @queue.start_worker(@id)
 
             begin
               after_fork
@@ -29,7 +29,7 @@ module ActiveSupport
             set_process_title("(stopping)")
 
             run_cleanup
-            @queue.stop_worker(@id, Process.pid)
+            @queue.stop_worker(@id)
           end
         end
 

data/lib/active_support/testing/parallelization.rb

@@ -47,19 +47,8 @@ module ActiveSupport
       end
 
       def shutdown
-        dead_worker_pids = @worker_pool.filter_map do |pid|
-          Process.waitpid(pid, Process::WNOHANG)
-        rescue Errno::ECHILD
-          pid
-        end
-        @queue_server.remove_dead_workers(dead_worker_pids)
-
         @queue_server.shutdown
-        @worker_pool.each do |pid|
-          Process.waitpid(pid)
-        rescue Errno::ECHILD
-          nil
-        end
+        @worker_pool.each { |pid| Process.waitpid pid }
       end
     end
   end