activesupport 6.1.4.6 → 7.0.0.alpha1

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