activesupport 7.2.3.1 → 8.1.4.1

data/lib/active_support/execution_context.rb

@@ -2,8 +2,48 @@
 
 module ActiveSupport
   module ExecutionContext # :nodoc:
+    class Record # :nodoc:
+      attr_reader :store, :current_attributes_instances
+
+      def initialize
+        @store = {}
+        @current_attributes_instances = {}
+        @stack = []
+      end
+
+      def push
+        @stack << @store << @current_attributes_instances
+        @store = {}
+        @current_attributes_instances = {}
+        self
+      end
+
+      def pop
+        @current_attributes_instances = @stack.pop
+        @store = @stack.pop
+        self
+      end
+
+      def flush
+        @stack = Array.new(@stack.size) { {} }
+        @store = {}
+        @current_attributes_instances = {}
+        self
+      end
+    end
+
     @after_change_callbacks = []
+
+    # Execution context nesting should only legitimately happen during test
+    # because the test case itself is wrapped in an executor, and it might call
+    # into a controller or job which should be executed with their own fresh context.
+    # However in production this should never happen, and for extra safety we make sure to
+    # fully clear the state at the end of the request or job cycle.
+    @nestable = false
+
     class << self
+      attr_accessor :nestable
+
       def after_change(&block)
         @after_change_callbacks << block
       end
@@ -14,9 +54,11 @@ module ActiveSupport
         options.symbolize_keys!
         keys = options.keys
 
-        store = self.store
+        store = record.store
 
-        previous_context = keys.zip(store.values_at(*keys)).to_h
+        previous_context = if block_given?
+          keys.zip(store.values_at(*keys)).to_h
+        end
 
         store.merge!(options)
         @after_change_callbacks.each(&:call)
@@ -32,21 +74,47 @@ module ActiveSupport
       end
 
       def []=(key, value)
-        store[key.to_sym] = value
+        record.store[key.to_sym] = value
         @after_change_callbacks.each(&:call)
       end
 
       def to_h
-        store.dup
+        record.store.dup
+      end
+
+      def push
+        if @nestable
+          record.push
+        else
+          clear
+        end
+        self
+      end
+
+      def pop
+        if @nestable
+          record.pop
+        else
+          clear
+        end
+        self
       end
 
       def clear
-        store.clear
+        IsolatedExecutionState[:active_support_execution_context] = nil
+      end
+
+      def flush
+        record.flush
+      end
+
+      def current_attributes_instances
+        record.current_attributes_instances
       end
 
       private
-        def store
-          IsolatedExecutionState[:active_support_execution_context] ||= {}
+        def record
+          IsolatedExecutionState[:active_support_execution_context] ||= Record.new
         end
     end
   end

data/lib/active_support/file_update_checker.rb

@@ -46,8 +46,11 @@ module ActiveSupport
         raise ArgumentError, "A block is required to initialize a FileUpdateChecker"
       end
 
-      @files = files.freeze
-      @glob  = compile_glob(dirs)
+      gem_paths = Gem.path
+      @files = files.reject { |file| File.expand_path(file).start_with?(*gem_paths) }.freeze
+
+      @globs = compile_glob(dirs)&.reject { |dir| dir.start_with?(*gem_paths) }
+
       @block = block
 
       @watched    = nil
@@ -103,7 +106,7 @@ module ActiveSupport
       def watched
         @watched || begin
           all = @files.select { |f| File.exist?(f) }
-          all.concat(Dir[@glob]) if @glob
+          all.concat(Dir[*@globs]) if @globs
           all.tap(&:uniq!)
         end
       end
@@ -145,10 +148,9 @@ module ActiveSupport
         hash.freeze # Freeze so changes aren't accidentally pushed
         return if hash.empty?
 
-        globs = hash.map do |key, value|
+        hash.map do |key, value|
           "#{escape(key)}/**/*#{compile_ext(value)}"
         end
-        "{#{globs.join(",")}}"
       end
 
       def escape(key)

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 = 1
+    TINY  = 4
     PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/active_support/gzip.rb

@@ -32,6 +32,7 @@ module ActiveSupport
     def self.compress(source, level = Zlib::DEFAULT_COMPRESSION, strategy = Zlib::DEFAULT_STRATEGY)
       output = Stream.new
       gz = Zlib::GzipWriter.new(output, level, strategy)
+      gz.mtime = 0
       gz.write(source)
       gz.close
       output.string

data/lib/active_support/hash_with_indifferent_access.rb

@@ -68,15 +68,15 @@ module ActiveSupport
     end
 
     def initialize(constructor = nil)
-      if constructor.respond_to?(:to_hash)
+      if constructor.nil?
+        super()
+      elsif constructor.respond_to?(:to_hash)
         super()
         update(constructor)
 
         hash = constructor.is_a?(Hash) ? constructor : constructor.to_hash
-        self.default = hash.default if hash.default
+        self.default = hash.default unless hash.default.nil?
         self.default_proc = hash.default_proc if hash.default_proc
-      elsif constructor.nil?
-        super()
       else
         super(constructor)
       end
@@ -95,11 +95,27 @@ module ActiveSupport
     #   hash[:key] = 'value'
     #
     # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+    #
+    # If the value is a Hash or contains one or multiple Hashes, they will be
+    # converted to +HashWithIndifferentAccess+.
     def []=(key, value)
       regular_writer(convert_key(key), convert_value(value, conversion: :assignment))
     end
 
-    alias_method :store, :[]=
+    # Assigns a new value to the hash:
+    #
+    #   hash = ActiveSupport::HashWithIndifferentAccess.new
+    #   hash[:key] = 'value'
+    #
+    # This value can be later fetched using either +:key+ or <tt>'key'</tt>.
+    #
+    # If the value is a Hash or contains one or multiple Hashes, they will be
+    # converted to +HashWithIndifferentAccess+. unless `convert_value: false`
+    # is set.
+    def store(key, value, convert_value: true)
+      value = convert_value(value, conversion: :assignment) if convert_value
+      regular_writer(convert_key(key), value)
+    end
 
     # Updates the receiver in-place, merging in the hashes passed as arguments:
     #
@@ -279,13 +295,13 @@ module ActiveSupport
     #   hash['a'] = nil
     #   hash.reverse_merge(a: 0, b: 1) # => {"a"=>nil, "b"=>1}
     def reverse_merge(other_hash)
-      super(self.class.new(other_hash))
+      super(cast(other_hash))
     end
     alias_method :with_defaults, :reverse_merge
 
     # Same semantics as +reverse_merge+ but modifies the receiver in-place.
     def reverse_merge!(other_hash)
-      super(self.class.new(other_hash))
+      super(cast(other_hash))
     end
     alias_method :with_defaults!, :reverse_merge!
 
@@ -294,7 +310,7 @@ module ActiveSupport
     #   h = { "a" => 100, "b" => 200 }
     #   h.replace({ "c" => 300, "d" => 400 }) # => {"c"=>300, "d"=>400}
     def replace(other_hash)
-      super(self.class.new(other_hash))
+      super(cast(other_hash))
     end
 
     # Removes the specified key from the hash.
@@ -311,10 +327,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
@@ -326,6 +338,7 @@ module ActiveSupport
       return to_enum(:select) unless block_given?
       dup.tap { |hash| hash.select!(*args, &block) }
     end
+    alias_method :filter, :select
 
     def reject(*args, &block)
       return to_enum(:reject) unless block_given?
@@ -381,13 +394,9 @@ 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) }
+      copy_defaults(copy)
     end
 
     def to_proc
@@ -395,17 +404,17 @@ module ActiveSupport
     end
 
     private
+      def cast(other)
+        self.class === other ? other : self.class.new(other)
+      end
+
       def convert_key(key)
         Symbol === key ? key.name : key
       end
 
       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,6 +425,17 @@ module ActiveSupport
         end
       end
 
+      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

data/lib/active_support/i18n_railtie.rb

@@ -2,6 +2,7 @@
 
 require "active_support"
 require "active_support/core_ext/array/wrap"
+require "rails/railtie"
 
 # :enddoc:
 
@@ -14,15 +15,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 +53,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 +67,8 @@ 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) }
+        reloader = app.config.file_watcher.new(I18n.load_path, 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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "concurrent/map"
+require "active_support/core_ext/module/delegation"
 require "active_support/i18n"
 
 module ActiveSupport
@@ -29,45 +30,61 @@ module ActiveSupport
     # before any of the rules that may already have been loaded.
     class Inflections
       @__instance__ = Concurrent::Map.new
+      @__en_instance__ = nil
+
+      class Uncountables # :nodoc:
+        include Enumerable
+
+        delegate :each, :pop, :empty?, :to_s, :==, :to_a, :to_ary, to: :@members
 
-      class Uncountables < Array
         def initialize
-          @regex_array = []
-          super
+          @members = []
+          @pattern = nil
         end
 
         def delete(entry)
-          super entry
-          @regex_array.delete(to_regex(entry))
+          @members.delete(entry)
+          @pattern = nil
+        end
+
+        def <<(word)
+          word = word.downcase
+          @members << word
+          @pattern = nil
+          self
         end
 
-        def <<(*word)
-          add(word)
+        def flatten
+          @members.dup
         end
 
         def add(words)
           words = words.flatten.map(&:downcase)
-          concat(words)
-          @regex_array += words.map { |word| to_regex(word) }
+          @members.concat(words)
+          @pattern = nil
           self
         end
 
         def uncountable?(str)
-          @regex_array.any? { |regex| regex.match? str }
-        end
-
-        private
-          def to_regex(string)
-            /\b#{::Regexp.escape(string)}\Z/i
+          if @pattern.nil?
+            members_pattern = Regexp.union(@members.map { |w| /#{Regexp.escape(w)}/i })
+            @pattern = /\b#{members_pattern}\Z/i
           end
+          @pattern.match?(str)
+        end
       end
 
       def self.instance(locale = :en)
+        return @__en_instance__ ||= new if locale == :en
+
         @__instance__[locale] ||= new
       end
 
       def self.instance_or_fallback(locale)
+        return @__en_instance__ ||= new if locale == :en
+
         I18n.fallbacks[locale].each do |k|
+          return @__en_instance__ if k == :en && @__en_instance__
           return @__instance__[k] if @__instance__.key?(k)
         end
         instance(locale)
@@ -248,7 +265,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
@@ -190,7 +190,7 @@ module ActiveSupport
     #   titleize('raiders_of_the_lost_ark')                      # => "Raiders Of The Lost Ark"
     #   titleize('string_ending_with_id', keep_id_suffix: true)  # => "String Ending With Id"
     def titleize(word, keep_id_suffix: false)
-      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])[a-z]/) do |match|
+      humanize(underscore(word), keep_id_suffix: keep_id_suffix).gsub(/\b(?<!\w['’`()])\p{Lower}/) do |match|
         match.capitalize
       end
     end
@@ -319,7 +319,8 @@ module ActiveSupport
         e.name.to_s == camel_cased_word.to_s)
     rescue LoadError => e
       message = e.respond_to?(:original_message) ? e.original_message : e.message
-      raise unless /Unable to autoload constant #{const_regexp(camel_cased_word)}/.match?(message)
+      constant_name = camel_cased_word.split("::").find { |part| !part.empty? } || camel_cased_word
+      raise unless message.include?("Unable to autoload constant #{constant_name}")
     end
 
     # Returns the suffix that should be added to a number to denote the position
@@ -349,23 +350,6 @@ module ActiveSupport
     end
 
     private
-      # Mounts a regular expression, returned as a string to ease interpolation,
-      # that will match part by part the given constant.
-      #
-      #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
-      #   const_regexp("::")            # => "::"
-      def const_regexp(camel_cased_word)
-        parts = camel_cased_word.split("::")
-
-        return Regexp.escape(camel_cased_word) if parts.empty?
-
-        last = parts.pop
-
-        parts.reverse!.inject(last) do |acc, part|
-          part.empty? ? acc : "#{part}(::#{acc})?"
-        end
-      end
-
       # Applies inflection rules for +singularize+ and +pluralize+.
       #
       # If passed an optional +locale+ parameter, the uncountables will be

data/lib/active_support/inflector/transliterate.rb

@@ -66,7 +66,10 @@ module ActiveSupport
       raise ArgumentError, "Cannot transliterate strings with #{string.encoding} encoding" unless ALLOWED_ENCODINGS_FOR_TRANSLITERATE.include?(string.encoding)
 
       return string.dup if string.ascii_only?
-      string = string.dup if string.frozen?
+
+      # Operate on a copy so the in-place force_encoding/encode! below never
+      # mutate the caller's (possibly non-frozen) string.
+      string = string.dup
 
       input_encoding = string.encoding
 
@@ -105,6 +108,11 @@ module ActiveSupport
     #   parameterize("Donald E. Knuth", separator: '_') # => "donald_e_knuth"
     #   parameterize("^très|Jolie__ ", separator: '_')  # => "tres_jolie"
     #
+    # To remove the unwanted characters instead of replacing them, pass an
+    # empty separator. +nil+ is treated the same way.
+    #
+    #   parameterize("Donald E. Knuth", separator: '') # => "donaldeknuth"
+    #
     # To preserve the case of the characters in a string, use the +preserve_case+ argument.
     #
     #   parameterize("Donald E. Knuth", preserve_case: true) # => "Donald-E-Knuth"
@@ -121,25 +129,25 @@ module ActiveSupport
     # By default, this parameter is set to <tt>nil</tt> and it will use
     # the configured <tt>I18n.locale</tt>.
     def parameterize(string, separator: "-", preserve_case: false, locale: nil)
+      separator ||= ""
+
       # Replace accented chars with their ASCII equivalents.
       parameterized_string = transliterate(string, locale: locale)
 
       # Turn unwanted chars into the separator.
       parameterized_string.gsub!(/[^a-z0-9\-_]+/i, separator)
 
-      unless separator.nil? || separator.empty?
-        if separator == "-"
-          re_duplicate_separator        = /-{2,}/
-          re_leading_trailing_separator = /^-|-$/i
+      unless separator.empty?
+        # No more than one of the separator in a row.
+        if separator.length == 1
+          parameterized_string.squeeze!(separator)
         else
           re_sep = Regexp.escape(separator)
-          re_duplicate_separator        = /#{re_sep}{2,}/
-          re_leading_trailing_separator = /^#{re_sep}|#{re_sep}$/i
+          parameterized_string.gsub!(/#{re_sep}{2,}/, separator)
         end
-        # No more than one of the separator in a row.
-        parameterized_string.gsub!(re_duplicate_separator, separator)
         # Remove leading/trailing separator.
-        parameterized_string.gsub!(re_leading_trailing_separator, "")
+        parameterized_string.delete_prefix!(separator)
+        parameterized_string.delete_suffix!(separator)
       end
 
       parameterized_string.downcase! unless preserve_case

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
@@ -30,45 +28,47 @@ module ActiveSupport
         @isolation_level = level
       end
 
-      def unique_id
-        self[:__id__] ||= Object.new
-      end
-
       def [](key)
-        state[key]
+        if state = @scope.current.active_support_execution_state
+          state[key]
+        end
       end
 
       def []=(key, value)
+        state = (@scope.current.active_support_execution_state ||= {})
         state[key] = value
       end
 
       def key?(key)
-        state.key?(key)
+        @scope.current.active_support_execution_state&.key?(key)
       end
 
       def delete(key)
-        state.delete(key)
+        @scope.current.active_support_execution_state&.delete(key)
       end
 
       def clear
-        state.clear
+        @scope.current.active_support_execution_state&.clear
       end
 
       def context
         scope.current
       end
 
-      def share_with(other)
+      def share_with(other, except: [], &block)
         # 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
-      end
-
-      private
-        def state
-          context.active_support_execution_state ||= {}
+        if state = other.active_support_execution_state
+          copied_state = state.dup
+          Array(except).each { |key| copied_state.delete(key) }
         end
+
+        old_state, context.active_support_execution_state = context.active_support_execution_state, copied_state
+        block.call
+      ensure
+        context.active_support_execution_state = old_state
+      end
     end
 
     self.isolation_level = :thread