activesupport 6.1.7.8 → 7.0.0.alpha1

data/lib/active_support/current_attributes.rb

@@ -143,13 +143,24 @@ module ActiveSupport
         current_instances.clear
       end
 
+      def _use_thread_variables=(value) # :nodoc:
+        clear_all
+        @@use_thread_variables = value
+      end
+      @@use_thread_variables = false
+
       private
         def generated_attribute_methods
           @generated_attribute_methods ||= Module.new.tap { |mod| include mod }
         end
 
         def current_instances
-          Thread.current[:current_attributes_instances] ||= {}
+          if @@use_thread_variables
+            Thread.current.thread_variable_get(:current_attributes_instances) ||
+              Thread.current.thread_variable_set(:current_attributes_instances, {})
+          else
+            Thread.current[:current_attributes_instances] ||= {}
+          end
         end
 
         def current_instances_key
@@ -164,7 +175,11 @@ module ActiveSupport
 
           send(name, *args, &block)
         end
-        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
+        ruby2_keywords(:method_missing)
+
+        def respond_to_missing?(name, _)
+          super || instance.respond_to?(name)
+        end
     end
 
     attr_accessor :attributes

data/lib/active_support/dependencies/interlock.rb

@@ -2,23 +2,19 @@
 
 require "active_support/concurrency/share_lock"
 
-module ActiveSupport #:nodoc:
-  module Dependencies #:nodoc:
+module ActiveSupport # :nodoc:
+  module Dependencies # :nodoc:
     class Interlock
       def initialize # :nodoc:
         @lock = ActiveSupport::Concurrency::ShareLock.new
       end
 
-      def loading
-        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load]) do
-          yield
-        end
+      def loading(&block)
+        @lock.exclusive(purpose: :load, compatible: [:load], after_compatible: [:load], &block)
       end
 
-      def unloading
-        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload]) do
-          yield
-        end
+      def unloading(&block)
+        @lock.exclusive(purpose: :unload, compatible: [:load, :unload], after_compatible: [:load, :unload], &block)
       end
 
       def start_unloading
@@ -37,16 +33,12 @@ module ActiveSupport #:nodoc:
         @lock.stop_sharing
       end
 
-      def running
-        @lock.sharing do
-          yield
-        end
+      def running(&block)
+        @lock.sharing(&block)
       end
 
-      def permit_concurrent_loads
-        @lock.yield_shares(compatible: [:load]) do
-          yield
-        end
+      def permit_concurrent_loads(&block)
+        @lock.yield_shares(compatible: [:load], &block)
       end
 
       def raw_state(&block) # :nodoc:

data/lib/active_support/dependencies/require_dependency.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ActiveSupport::Dependencies::RequireDependency
+  # <b>Warning:</b> This method is obsolete. The semantics of the autoloader
+  # match Ruby's and you do not need to be defensive with load order anymore.
+  # Just refer to classes and modules normally.
+  #
+  # Engines that do not control the mode in which their parent application runs
+  # should call +require_dependency+ where needed in case the runtime mode is
+  # +:classic+.
+  def require_dependency(filename)
+    filename = filename.to_path if filename.respond_to?(:to_path)
+
+    unless filename.is_a?(String)
+      raise ArgumentError, "the file name must be either a String or implement #to_path -- you passed #{filename.inspect}"
+    end
+
+    if abspath = ActiveSupport::Dependencies.search_for_file(filename)
+      require abspath
+    else
+      require filename
+    end
+  end
+
+  # We could define require_dependency in Object directly, but a module makes
+  # the extension apparent if you list ancestors.
+  Object.prepend(self)
+end