activerecord 4.2.11.1 → 6.0.3

data/lib/active_record/relation/delegation.rb

@@ -1,15 +1,15 @@
-require 'set'
-require 'active_support/concern'
-require 'active_support/deprecation'
+# frozen_string_literal: true
+
+require "mutex_m"
 
 module ActiveRecord
   module Delegation # :nodoc:
-    module DelegateCache
-      def relation_delegate_class(klass) # :nodoc:
+    module DelegateCache # :nodoc:
+      def relation_delegate_class(klass)
         @relation_delegate_cache[klass]
       end
 
-      def initialize_relation_delegate_cache # :nodoc:
+      def initialize_relation_delegate_cache
         @relation_delegate_cache = cache = {}
         [
           ActiveRecord::Relation,
@@ -19,7 +19,11 @@ module ActiveRecord
           delegate = Class.new(klass) {
             include ClassSpecificRelation
           }
-          const_set klass.name.gsub('::', '_'), delegate
+          include_relation_methods(delegate)
+          mangled_name = klass.name.gsub("::", "_")
+          const_set mangled_name, delegate
+          private_constant mangled_name
+
           cache[klass] = delegate
         end
       end
@@ -28,8 +32,51 @@ module ActiveRecord
         child_class.initialize_relation_delegate_cache
         super
       end
+
+      def generate_relation_method(method)
+        generated_relation_methods.generate_method(method)
+      end
+
+      protected
+        def include_relation_methods(delegate)
+          superclass.include_relation_methods(delegate) unless base_class?
+          delegate.include generated_relation_methods
+        end
+
+      private
+        def generated_relation_methods
+          @generated_relation_methods ||= GeneratedRelationMethods.new.tap do |mod|
+            const_set(:GeneratedRelationMethods, mod)
+            private_constant :GeneratedRelationMethods
+          end
+        end
     end
 
+    class GeneratedRelationMethods < Module # :nodoc:
+      include Mutex_m
+
+      def generate_method(method)
+        synchronize do
+          return if method_defined?(method)
+
+          if /\A[a-zA-Z_]\w*[!?]?\z/.match?(method)
+            definition = RUBY_VERSION >= "2.7" ? "..." : "*args, &block"
+            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{method}(#{definition})
+                scoping { klass.#{method}(#{definition}) }
+              end
+            RUBY
+          else
+            define_method(method) do |*args, &block|
+              scoping { klass.public_send(method, *args, &block) }
+            end
+            ruby2_keywords(method) if respond_to?(:ruby2_keywords, true)
+          end
+        end
+      end
+    end
+    private_constant :GeneratedRelationMethods
+
     extend ActiveSupport::Concern
 
     # This module creates compiled delegation methods dynamically at runtime, which makes
@@ -37,104 +84,48 @@ module ActiveRecord
     # may vary depending on the klass of a relation, so we create a subclass of Relation
     # for each different klass, and the delegations are compiled into that subclass only.
 
-    BLACKLISTED_ARRAY_METHODS = [
-      :compact!, :flatten!, :reject!, :reverse!, :rotate!, :map!,
-      :shuffle!, :slice!, :sort!, :sort_by!, :delete_if,
-      :keep_if, :pop, :shift, :delete_at, :select!
-    ].to_set # :nodoc:
-
-    delegate :to_xml, :to_yaml, :length, :collect, :map, :each, :all?, :include?, :to_ary, :join, to: :to_a
+    delegate :to_xml, :encode_with, :length, :each, :join,
+             :[], :&, :|, :+, :-, :sample, :reverse, :rotate, :compact, :in_groups, :in_groups_of,
+             :to_sentence, :to_formatted_s, :as_json,
+             :shuffle, :split, :slice, :index, :rindex, to: :records
 
-    delegate :table_name, :quoted_table_name, :primary_key, :quoted_primary_key,
-             :connection, :columns_hash, :to => :klass
+    delegate :primary_key, :connection, to: :klass
 
     module ClassSpecificRelation # :nodoc:
       extend ActiveSupport::Concern
 
-      included do
-        @delegation_mutex = Mutex.new
-      end
-
       module ClassMethods # :nodoc:
         def name
           superclass.name
         end
+      end
 
-        def delegate_to_scoped_klass(method)
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
-
-            if method.to_s =~ /\A[a-zA-Z_]\w*[!?]?\z/
-              module_eval <<-RUBY, __FILE__, __LINE__ + 1
-                def #{method}(*args, &block)
-                  scoping { @klass.#{method}(*args, &block) }
-                end
-              RUBY
-            else
-              define_method method do |*args, &block|
-                scoping { @klass.public_send(method, *args, &block) }
-              end
-            end
-          end
-        end
-
-        def delegate(method, opts = {})
-          @delegation_mutex.synchronize do
-            return if method_defined?(method)
+      private
+        def method_missing(method, *args, &block)
+          if @klass.respond_to?(method)
+            @klass.generate_relation_method(method)
+            scoping { @klass.public_send(method, *args, &block) }
+          else
             super
           end
         end
-      end
-
-      protected
-
-      def method_missing(method, *args, &block)
-        if @klass.respond_to?(method)
-          self.class.delegate_to_scoped_klass(method)
-          scoping { @klass.public_send(method, *args, &block) }
-        elsif arel.respond_to?(method)
-          self.class.delegate method, :to => :arel
-          arel.public_send(method, *args, &block)
-        else
-          super
-        end
-      end
+        ruby2_keywords(:method_missing) if respond_to?(:ruby2_keywords, true)
     end
 
     module ClassMethods # :nodoc:
-      def create(klass, *args)
-        relation_class_for(klass).new(klass, *args)
+      def create(klass, *args, **kwargs)
+        relation_class_for(klass).new(klass, *args, **kwargs)
       end
 
       private
-
-      def relation_class_for(klass)
-        klass.relation_delegate_class(self)
-      end
-    end
-
-    def respond_to?(method, include_private = false)
-      super || @klass.respond_to?(method, include_private) ||
-        array_delegable?(method) ||
-        arel.respond_to?(method, include_private)
-    end
-
-    protected
-
-    def array_delegable?(method)
-      Array.method_defined?(method) && BLACKLISTED_ARRAY_METHODS.exclude?(method)
+        def relation_class_for(klass)
+          klass.relation_delegate_class(self)
+        end
     end
 
-    def method_missing(method, *args, &block)
-      if @klass.respond_to?(method)
-        scoping { @klass.public_send(method, *args, &block) }
-      elsif array_delegable?(method)
-        to_a.public_send(method, *args, &block)
-      elsif arel.respond_to?(method)
-        arel.public_send(method, *args, &block)
-      else
-        super
+    private
+      def respond_to_missing?(method, _)
+        super || @klass.respond_to?(method)
       end
-    end
   end
 end