activesupport 6.0.0.beta1 → 6.0.1.rc1

data/lib/active_support/current_attributes.rb

@@ -119,10 +119,16 @@ module ActiveSupport
         end
       end
 
+      # Calls this block before #reset is called on the instance. Used for resetting external collaborators that depend on current values.
+      def before_reset(&block)
+        set_callback :reset, :before, &block
+      end
+
       # Calls this block after #reset is called on the instance. Used for resetting external collaborators, like Time.zone.
       def resets(&block)
         set_callback :reset, :after, &block
       end
+      alias_method :after_reset, :resets
 
       delegate :set, :reset, to: :instance
 

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.
@@ -196,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)
@@ -225,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
 
@@ -321,9 +349,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!
@@ -634,7 +662,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)
@@ -690,7 +718,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
@@ -764,6 +792,14 @@ module ActiveSupport #:nodoc:
     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/dependencies/zeitwerk_integration.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require "set"
+require "active_support/core_ext/string/inflections"
+
+module ActiveSupport
+  module Dependencies
+    module ZeitwerkIntegration # :nodoc: all
+      module Decorations
+        def clear
+          Dependencies.unload_interlock do
+            Rails.autoloaders.main.reload
+          rescue Zeitwerk::ReloadingDisabledError
+            raise "reloading is disabled because config.cache_classes is true"
+          end
+        end
+
+        def constantize(cpath)
+          ActiveSupport::Inflector.constantize(cpath)
+        end
+
+        def safe_constantize(cpath)
+          ActiveSupport::Inflector.safe_constantize(cpath)
+        end
+
+        def autoloaded_constants
+          Rails.autoloaders.main.unloadable_cpaths
+        end
+
+        def autoloaded?(object)
+          cpath = object.is_a?(Module) ? real_mod_name(object) : object.to_s
+          Rails.autoloaders.main.unloadable_cpath?(cpath)
+        end
+
+        def verbose=(verbose)
+          l = verbose ? logger || Rails.logger : nil
+          Rails.autoloaders.each { |autoloader| autoloader.logger = l }
+        end
+
+        def unhook!
+          :no_op
+        end
+      end
+
+      module RequireDependency
+        def require_dependency(filename)
+          filename = filename.to_path if filename.respond_to?(:to_path)
+          if abspath = ActiveSupport::Dependencies.search_for_file(filename)
+            require abspath
+          else
+            require filename
+          end
+        end
+      end
+
+      module Inflector
+        # Concurrent::Map is not needed. This is a private class, and overrides
+        # must be defined while the application boots.
+        @overrides = {}
+
+        def self.camelize(basename, _abspath)
+          @overrides[basename] || basename.camelize
+        end
+
+        def self.inflect(overrides)
+          @overrides.merge!(overrides)
+        end
+      end
+
+      class << self
+        def take_over(enable_reloading:)
+          setup_autoloaders(enable_reloading)
+          freeze_paths
+          decorate_dependencies
+        end
+
+        private
+
+          def setup_autoloaders(enable_reloading)
+            Dependencies.autoload_paths.each do |autoload_path|
+              # Zeitwerk only accepts existing directories in `push_dir` to
+              # prevent misconfigurations.
+              next unless File.directory?(autoload_path)
+
+              autoloader = \
+                autoload_once?(autoload_path) ? Rails.autoloaders.once : Rails.autoloaders.main
+
+              autoloader.push_dir(autoload_path)
+              autoloader.do_not_eager_load(autoload_path) unless eager_load?(autoload_path)
+            end
+
+            Rails.autoloaders.main.enable_reloading if enable_reloading
+            Rails.autoloaders.each(&:setup)
+          end
+
+          def autoload_once?(autoload_path)
+            Dependencies.autoload_once_paths.include?(autoload_path)
+          end
+
+          def eager_load?(autoload_path)
+            Dependencies._eager_load_paths.member?(autoload_path)
+          end
+
+          def freeze_paths
+            Dependencies.autoload_paths.freeze
+            Dependencies.autoload_once_paths.freeze
+            Dependencies._eager_load_paths.freeze
+          end
+
+          def decorate_dependencies
+            Dependencies.unhook!
+            Dependencies.singleton_class.prepend(Decorations)
+            Object.prepend(RequireDependency)
+          end
+      end
+    end
+  end
+end

data/lib/active_support/deprecation/method_wrappers.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/array/extract_options"
+require "active_support/core_ext/module/redefine_method"
 
 module ActiveSupport
   class Deprecation
@@ -52,29 +53,17 @@ 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.define_method(with_method) do |*args, &block|
+            method = target_module.instance_method(method_name)
+            target_module.redefine_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
-              send(without_method, *args, &block)
-            end
-
-            target_module.alias_method(without_method, method_name)
-            target_module.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.bind(self).call(*args, &block)
             end
           else
+            mod ||= Module.new
             mod.define_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
               super(*args, &block)
@@ -82,7 +71,7 @@ module ActiveSupport
           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

@@ -120,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, &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"
 
@@ -130,6 +137,14 @@ 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
+
       # Returns the class of the new constant.
       #
       #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
@@ -144,8 +159,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/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,15 +37,17 @@ 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) }
+            direct_descendants.each do |direct_descendant|
+              acc << direct_descendant
+              accumulate_descendants(direct_descendant, acc)
+            end
           end
         end
     end
@@ -59,5 +64,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.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
@@ -339,8 +338,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