activesupport 5.2.8.1 → 6.0.6

data/lib/active_support/dependencies.rb

@@ -20,6 +20,9 @@ module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     extend self
 
+    UNBOUND_METHOD_MODULE_NAME = Module.instance_method(:name)
+    private_constant :UNBOUND_METHOD_MODULE_NAME
+
     mattr_accessor :interlock, default: Interlock.new
 
     # :doc:
@@ -70,6 +73,11 @@ module ActiveSupport #:nodoc:
     # only once. All directories in this set must also be present in +autoload_paths+.
     mattr_accessor :autoload_once_paths, default: []
 
+    # This is a private set that collects all eager load paths during bootstrap.
+    # Useful for Zeitwerk integration. Its public interface is the config.* path
+    # accessors of each engine.
+    mattr_accessor :_eager_load_paths, default: Set.new
+
     # An array of qualified constant names that have been loaded. Adding a name
     # to this array will cause it to be unloaded the next time Dependencies are
     # cleared.
@@ -79,6 +87,12 @@ module ActiveSupport #:nodoc:
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants, default: []
 
+    # The logger used when tracing autoloads.
+    mattr_accessor :logger
+
+    # If true, trace autoloads with +logger.debug+.
+    mattr_accessor :verbose, default: false
+
     # The WatchStack keeps a stack of the modules being watched as files are
     # loaded. If a file in the process of being loaded (parent.rb) triggers the
     # load of another file (child.rb) the stack will ensure that child.rb
@@ -140,7 +154,7 @@ module ActiveSupport #:nodoc:
 
           # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
+            constants << ([namespace, suffix] - ["Object"]).join("::")
           end
         end
         constants
@@ -190,6 +204,11 @@ module ActiveSupport #:nodoc:
         end
       end
 
+      def self.include_into(base)
+        base.include(self)
+        append_features(base)
+      end
+
       def const_missing(const_name)
         from_mod = anonymous? ? guess_for_anonymous(const_name) : self
         Dependencies.load_missing_constant(from_mod, const_name)
@@ -219,6 +238,21 @@ module ActiveSupport #:nodoc:
         base.class_eval do
           define_method(:load, Kernel.instance_method(:load))
           private :load
+
+          define_method(:require, Kernel.instance_method(:require))
+          private :require
+        end
+      end
+
+      def self.include_into(base)
+        base.include(self)
+
+        if base.instance_method(:load).owner == base
+          base.remove_method(:load)
+        end
+
+        if base.instance_method(:require).owner == base
+          base.remove_method(:require)
         end
       end
 
@@ -279,7 +313,6 @@ module ActiveSupport #:nodoc:
       end
 
       private
-
         def load(file, wrap = false)
           result = false
           load_dependency(file) { result = super }
@@ -315,9 +348,9 @@ module ActiveSupport #:nodoc:
     end
 
     def hook!
-      Object.class_eval { include Loadable }
-      Module.class_eval { include ModuleConstMissing }
-      Exception.class_eval { include Blamable }
+      Loadable.include_into(Object)
+      ModuleConstMissing.include_into(Module)
+      Exception.include(Blamable)
     end
 
     def unhook!
@@ -334,7 +367,12 @@ module ActiveSupport #:nodoc:
       require_or_load(path || file_name)
     rescue LoadError => load_error
       if file_name = load_error.message[/ -- (.*?)(\.rb)?$/, 1]
-        load_error.message.replace(message % file_name)
+        load_error_message = if load_error.respond_to?(:original_message)
+          load_error.original_message
+        else
+          load_error.message
+        end
+        load_error_message.replace(message % file_name)
         load_error.copy_blame!(load_error)
       end
       raise
@@ -349,7 +387,7 @@ module ActiveSupport #:nodoc:
     end
 
     def require_or_load(file_name, const_path = nil)
-      file_name = $` if file_name =~ /\.rb\z/
+      file_name = file_name.chomp(".rb")
       expanded = File.expand_path(file_name)
       return if loaded.include?(expanded)
 
@@ -399,7 +437,7 @@ module ActiveSupport #:nodoc:
     # constant paths which would cause Dependencies to attempt to load this
     # file.
     def loadable_constants_for_path(path, bases = autoload_paths)
-      path = $` if path =~ /\.rb\z/
+      path = path.chomp(".rb")
       expanded_path = File.expand_path(path)
       paths = []
 
@@ -408,7 +446,7 @@ module ActiveSupport #:nodoc:
         next unless expanded_path.start_with?(expanded_root)
 
         root_size = expanded_root.size
-        next if expanded_path[root_size] != ?/.freeze
+        next if expanded_path[root_size] != ?/
 
         nesting = expanded_path[(root_size + 1)..-1]
         paths << nesting.camelize unless nesting.blank?
@@ -420,7 +458,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
+      path_suffix += ".rb" unless path_suffix.ends_with?(".rb")
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -454,6 +492,7 @@ module ActiveSupport #:nodoc:
       return nil unless base_path = autoloadable_module?(path_suffix)
       mod = Module.new
       into.const_set const_name, mod
+      log("constant #{qualified_name} autoloaded (module autovivified from #{File.join(base_path, path_suffix)})")
       autoloaded_constants << qualified_name unless autoload_once_paths.include?(base_path)
       autoloaded_constants.uniq!
       mod
@@ -495,26 +534,31 @@ module ActiveSupport #:nodoc:
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
-      qualified_name = qualified_name_for from_mod, const_name
+      qualified_name = qualified_name_for(from_mod, const_name)
       path_suffix = qualified_name.underscore
 
       file_path = search_for_file(path_suffix)
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, "".freeze)
+        expanded.sub!(/\.rb\z/, "")
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
         else
           require_or_load(expanded, qualified_name)
-          raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it" unless from_mod.const_defined?(const_name, false)
-          return from_mod.const_get(const_name)
+
+          if from_mod.const_defined?(const_name, false)
+            log("constant #{qualified_name} autoloaded from #{expanded}.rb")
+            return from_mod.const_get(const_name)
+          else
+            raise LoadError, "Unable to autoload constant #{qualified_name}, expected #{file_path} to define it"
+          end
         end
       elsif mod = autoload_module!(from_mod, const_name, qualified_name, path_suffix)
         return mod
-      elsif (parent = from_mod.parent) && parent != from_mod &&
-            ! from_mod.parents.any? { |p| p.const_defined?(const_name, false) }
+      elsif (parent = from_mod.module_parent) && parent != from_mod &&
+            ! from_mod.module_parents.any? { |p| p.const_defined?(const_name, false) }
         # If our parents do not have a constant named +const_name+ then we are free
         # to attempt to load upwards. If they do have such a constant, then this
         # const_missing must be due to from_mod::const_name, which should not
@@ -558,6 +602,7 @@ module ActiveSupport #:nodoc:
     # as the environment will be in an inconsistent state, e.g. other constants
     # may have already been unloaded and not accessible.
     def remove_unloadable_constants!
+      log("removing unloadable constants")
       autoloaded_constants.each { |const| remove_constant const }
       autoloaded_constants.clear
       Reference.clear!
@@ -621,7 +666,7 @@ module ActiveSupport #:nodoc:
 
     # Determine if the given constant has been automatically loaded.
     def autoloaded?(desc)
-      return false if desc.is_a?(Module) && desc.anonymous?
+      return false if desc.is_a?(Module) && real_mod_name(desc).nil?
       name = to_constant_name desc
       return false unless qualified_const_defined?(name)
       autoloaded_constants.include?(name)
@@ -677,7 +722,7 @@ module ActiveSupport #:nodoc:
       when String then desc.sub(/^::/, "")
       when Symbol then desc.to_s
       when Module
-        desc.name ||
+        real_mod_name(desc) ||
           raise(ArgumentError, "Anonymous modules have no name to be referenced by")
       else raise TypeError, "Not a valid constant descriptor: #{desc.inspect}"
       end
@@ -747,6 +792,17 @@ module ActiveSupport #:nodoc:
         # The constant is no longer reachable, just skip it.
       end
     end
+
+    def log(message)
+      logger.debug("autoloading: #{message}") if logger && verbose
+    end
+
+    private
+      # Returns the original name of a class or module even if `name` has been
+      # overridden.
+      def real_mod_name(mod)
+        UNBOUND_METHOD_MODULE_NAME.bind(mod).call
+      end
   end
 end
 

data/lib/active_support/deprecation/behaviors.rb

@@ -43,7 +43,7 @@ module ActiveSupport
                                                 deprecation_horizon: deprecation_horizon)
       },
 
-      silence: ->(message, callstack, deprecation_horizon, gem_name) {},
+      silence: ->(message, callstack, deprecation_horizon, gem_name) { },
     }
 
     # Behavior module allows to determine how to display deprecation messages.

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module/aliasing"
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/module/redefine_method"
 
 module ActiveSupport
   class Deprecation
@@ -53,37 +53,31 @@ module ActiveSupport
         options = method_names.extract_options!
         deprecator = options.delete(:deprecator) || self
         method_names += options.keys
-        mod = Module.new
+        mod = nil
 
         method_names.each do |method_name|
           if target_module.method_defined?(method_name) || target_module.private_method_defined?(method_name)
-            aliased_method, punctuation = method_name.to_s.sub(/([?!=])$/, ""), $1
-            with_method = "#{aliased_method}_with_deprecation#{punctuation}"
-            without_method = "#{aliased_method}_without_deprecation#{punctuation}"
-
-            target_module.send(:define_method, with_method) do |*args, &block|
-              deprecator.deprecation_warning(method_name, options[method_name])
-              send(without_method, *args, &block)
-            end
-
-            target_module.send(:alias_method, without_method, method_name)
-            target_module.send(:alias_method, method_name, with_method)
-
-            case
-            when target_module.protected_method_defined?(without_method)
-              target_module.send(:protected, method_name)
-            when target_module.private_method_defined?(without_method)
-              target_module.send(:private, method_name)
+            method = target_module.instance_method(method_name)
+            target_module.module_eval do
+              redefine_method(method_name) do |*args, &block|
+                deprecator.deprecation_warning(method_name, options[method_name])
+                method.bind(self).call(*args, &block)
+              end
+              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
             end
           else
-            mod.send(:define_method, method_name) do |*args, &block|
-              deprecator.deprecation_warning(method_name, options[method_name])
-              super(*args, &block)
+            mod ||= Module.new
+            mod.module_eval do
+              define_method(method_name) do |*args, &block|
+                deprecator.deprecation_warning(method_name, options[method_name])
+                super(*args, &block)
+              end
+              ruby2_keywords(method_name) if respond_to?(:ruby2_keywords, true)
             end
           end
         end
 
-        target_module.prepend(mod) unless mod.instance_methods(false).empty?
+        target_module.prepend(mod) if mod
       end
     end
   end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/regexp"
-
 module ActiveSupport
   class Deprecation
     class DeprecationProxy #:nodoc:
@@ -122,7 +120,14 @@ module ActiveSupport
     #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
     #        (Backtrace information…)
     #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
-    class DeprecatedConstantProxy < DeprecationProxy
+    class DeprecatedConstantProxy < Module
+      def self.new(*args, **kwargs, &block)
+        object = args.first
+
+        return object unless object
+        super
+      end
+
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance, message: "#{old_const} is deprecated! Use #{new_const} instead.")
         require "active_support/inflector/methods"
 
@@ -132,6 +137,18 @@ module ActiveSupport
         @message = message
       end
 
+      instance_methods.each { |m| undef_method m unless /^__|^object_id$/.match?(m) }
+
+      # Don't give a deprecation warning on inspect since test/unit and error
+      # logs rely on it for diagnostics.
+      def inspect
+        target.inspect
+      end
+
+      # Don't give a deprecation warning on methods that IRB may invoke
+      # during tab-completion.
+      delegate :hash, :instance_methods, :name, :respond_to?, to: :target
+
       # Returns the class of the new constant.
       #
       #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
@@ -146,8 +163,14 @@ module ActiveSupport
           ActiveSupport::Inflector.constantize(@new_const.to_s)
         end
 
-        def warn(callstack, called, args)
-          @deprecator.warn(@message, callstack)
+        def const_missing(name)
+          @deprecator.warn(@message, caller_locations)
+          target.const_get(name)
+        end
+
+        def method_missing(called, *args, &block)
+          @deprecator.warn(@message, caller_locations)
+          target.__send__(called, *args, &block)
         end
     end
   end

data/lib/active_support/deprecation.rb

@@ -35,7 +35,7 @@ module ActiveSupport
     # and the second is a library name.
     #
     #   ActiveSupport::Deprecation.new('2.0', 'MyLibrary')
-    def initialize(deprecation_horizon = "6.0", gem_name = "Rails")
+    def initialize(deprecation_horizon = "6.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/descendants_tracker.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "weakref"
+
 module ActiveSupport
   # This module provides an internal implementation to track descendants
   # which is faster than iterating through ObjectSpace.
@@ -8,7 +10,8 @@ module ActiveSupport
 
     class << self
       def direct_descendants(klass)
-        @@direct_descendants[klass] || []
+        descendants = @@direct_descendants[klass]
+        descendants ? descendants.to_a : []
       end
 
       def descendants(klass)
@@ -20,10 +23,10 @@ module ActiveSupport
       def clear
         if defined? ActiveSupport::Dependencies
           @@direct_descendants.each do |klass, descendants|
-            if ActiveSupport::Dependencies.autoloaded?(klass)
+            if Dependencies.autoloaded?(klass)
               @@direct_descendants.delete(klass)
             else
-              descendants.reject! { |v| ActiveSupport::Dependencies.autoloaded?(v) }
+              descendants.reject! { |v| Dependencies.autoloaded?(v) }
             end
           end
         else
@@ -34,16 +37,18 @@ module ActiveSupport
       # This is the only method that is not thread safe, but is only ever called
       # during the eager loading phase.
       def store_inherited(klass, descendant)
-        (@@direct_descendants[klass] ||= []) << descendant
+        (@@direct_descendants[klass] ||= DescendantsArray.new) << descendant
       end
 
       private
-      def accumulate_descendants(klass, acc)
-        if direct_descendants = @@direct_descendants[klass]
-          acc.concat(direct_descendants)
-          direct_descendants.each { |direct_descendant| accumulate_descendants(direct_descendant, acc) }
+        def accumulate_descendants(klass, acc)
+          if direct_descendants = @@direct_descendants[klass]
+            direct_descendants.each do |direct_descendant|
+              acc << direct_descendant
+              accumulate_descendants(direct_descendant, acc)
+            end
+          end
         end
-      end
     end
 
     def inherited(base)
@@ -58,5 +63,46 @@ module ActiveSupport
     def descendants
       DescendantsTracker.descendants(self)
     end
+
+    # DescendantsArray is an array that contains weak references to classes.
+    class DescendantsArray # :nodoc:
+      include Enumerable
+
+      def initialize
+        @refs = []
+      end
+
+      def initialize_copy(orig)
+        @refs = @refs.dup
+      end
+
+      def <<(klass)
+        cleanup!
+        @refs << WeakRef.new(klass)
+      end
+
+      def each
+        @refs.each do |ref|
+          yield ref.__getobj__
+        rescue WeakRef::RefError
+        end
+      end
+
+      def refs_size
+        @refs.size
+      end
+
+      def cleanup!
+        @refs.delete_if { |ref| !ref.weakref_alive? }
+      end
+
+      def reject!
+        @refs.reject! do |ref|
+          yield ref.__getobj__
+        rescue WeakRef::RefError
+          true
+        end
+      end
+    end
   end
 end

data/lib/active_support/duration/iso8601_parser.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "strscan"
-require "active_support/core_ext/regexp"
 
 module ActiveSupport
   class Duration
@@ -14,8 +13,8 @@ module ActiveSupport
       class ParsingError < ::ArgumentError; end
 
       PERIOD_OR_COMMA = /\.|,/
-      PERIOD = ".".freeze
-      COMMA = ",".freeze
+      PERIOD = "."
+      COMMA = ","
 
       SIGN_MARKER = /\A\-|\+|/
       DATE_MARKER = /P/
@@ -81,7 +80,6 @@ module ActiveSupport
       end
 
       private
-
         def finished?
           scanner.eos?
         end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
-require "active_support/core_ext/hash/transform_values"
 
 module ActiveSupport
   class Duration
@@ -15,14 +14,14 @@ module ActiveSupport
       # Builds and returns output string.
       def serialize
         parts, sign = normalize
-        return "PT0S".freeze if parts.empty?
+        return "PT0S" if parts.empty?
 
-        output = "P".dup
+        output = +"P"
         output << "#{parts[:years]}Y"   if parts.key?(:years)
         output << "#{parts[:months]}M"  if parts.key?(:months)
         output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
         output << "#{parts[:days]}D"    if parts.key?(:days)
-        time = "".dup
+        time = +""
         time << "#{parts[:hours]}H"     if parts.key?(:hours)
         time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
         if parts.key?(:seconds)
@@ -33,7 +32,6 @@ module ActiveSupport
       end
 
       private
-
         # Return pair of duration's parts and whole duration sign.
         # Parts are summarized (as they can become repetitive due to addition, etc).
         # Zero parts are removed as not significant.

data/lib/active_support/duration.rb

@@ -4,7 +4,6 @@ require "active_support/core_ext/array/conversions"
 require "active_support/core_ext/module/delegation"
 require "active_support/core_ext/object/acts_like"
 require "active_support/core_ext/string/filters"
-require "active_support/deprecation"
 
 module ActiveSupport
   # Provides accurate date and time measurements using Date#advance and
@@ -199,7 +198,6 @@ module ActiveSupport
       end
 
       private
-
         def calculate_total_seconds(parts)
           parts.inject(0) do |total, (part, value)|
             total + value * PARTS_IN_SECONDS[part]
@@ -214,8 +212,11 @@ module ActiveSupport
     end
 
     def coerce(other) #:nodoc:
-      if Scalar === other
+      case other
+      when Scalar
         [other, self]
+      when Duration
+        [Scalar.new(other.value), self]
       else
         [Scalar.new(other), self]
       end
@@ -336,8 +337,8 @@ module ActiveSupport
     #   1.year.to_i     # => 31556952
     #
     # In such cases, Ruby's core
-    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
-    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # Date[https://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[https://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
     # date and time arithmetic.
     def to_i
       @value.to_i
@@ -370,10 +371,9 @@ module ActiveSupport
     alias :before :ago
 
     def inspect #:nodoc:
-      return "0 seconds" if parts.empty?
+      return "#{value} seconds" if parts.empty?
 
       parts.
-        reduce(::Hash.new(0)) { |h, (l, r)| h[l] += r; h }.
         sort_by { |unit,  _ | PARTS.index(unit) }.
         map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
         to_sentence(locale: ::I18n.default_locale)
@@ -398,7 +398,6 @@ module ActiveSupport
     end
 
     private
-
       def sum(sign, time = ::Time.current)
         unless time.acts_like?(:time) || time.acts_like?(:date)
           raise ::ArgumentError, "expected a time or date, got #{time.inspect}"

data/lib/active_support/encrypted_configuration.rb

@@ -38,10 +38,6 @@ module ActiveSupport
         @options ||= ActiveSupport::InheritableOptions.new(config)
       end
 
-      def serialize(config)
-        config.present? ? YAML.dump(config) : ""
-      end
-
       def deserialize(config)
         YAML.load(config).presence || {}
       end

data/lib/active_support/encrypted_file.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "pathname"
+require "tmpdir"
 require "active_support/message_encryptor"
 
 module ActiveSupport
@@ -67,7 +68,7 @@ module ActiveSupport
 
         write(updated_contents) if updated_contents != contents
       ensure
-        FileUtils.rm(tmp_path) if tmp_path.exist?
+        FileUtils.rm(tmp_path) if tmp_path&.exist?
       end
 
 
@@ -93,7 +94,7 @@ module ActiveSupport
       end
 
       def handle_missing_key
-        raise MissingKeyError, key_path: key_path, env_key: env_key if raise_if_missing_key
+        raise MissingKeyError.new(key_path: key_path, env_key: env_key) if raise_if_missing_key
       end
   end
 end