activesupport 6.1.0 → 7.0.0

data/lib/active_support/current_attributes.rb

@@ -2,6 +2,7 @@
 
 require "active_support/callbacks"
 require "active_support/core_ext/enumerable"
+require "active_support/core_ext/module/delegation"
 
 module ActiveSupport
   # Abstract super class that provides a thread-isolated attributes singleton, which resets automatically
@@ -97,25 +98,37 @@ module ActiveSupport
 
       # Declares one or more attributes that will be given both class and instance accessor methods.
       def attribute(*names)
-        generated_attribute_methods.module_eval do
+        ActiveSupport::CodeGenerator.batch(generated_attribute_methods, __FILE__, __LINE__) do |owner|
           names.each do |name|
-            define_method(name) do
-              attributes[name.to_sym]
+            owner.define_cached_method(name, namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}" <<
+                "attributes[:#{name}]" <<
+                "end"
             end
-
-            define_method("#{name}=") do |attribute|
-              attributes[name.to_sym] = attribute
+            owner.define_cached_method("#{name}=", namespace: :current_attributes) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "attributes[:#{name}] = value" <<
+                "end"
             end
           end
         end
 
-        names.each do |name|
-          define_singleton_method(name) do
-            instance.public_send(name)
-          end
-
-          define_singleton_method("#{name}=") do |attribute|
-            instance.public_send("#{name}=", attribute)
+        ActiveSupport::CodeGenerator.batch(singleton_class, __FILE__, __LINE__) do |owner|
+          names.each do |name|
+            owner.define_cached_method(name, namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}" <<
+                "instance.#{name}" <<
+                "end"
+            end
+            owner.define_cached_method("#{name}=", namespace: :current_attributes_delegation) do |batch|
+              batch <<
+                "def #{name}=(value)" <<
+                "instance.#{name} = value" <<
+                "end"
+            end
           end
         end
       end
@@ -148,7 +161,7 @@ module ActiveSupport
         end
 
         def current_instances
-          Thread.current[:current_attributes_instances] ||= {}
+          IsolatedExecutionState[:current_attributes_instances] ||= {}
         end
 
         def current_instances_key
@@ -163,6 +176,11 @@ module ActiveSupport
 
           send(name, *args, &block)
         end
+        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