activerecord 5.0.7.2 → 6.0.3.4

data/lib/active_record/associations/builder/has_and_belongs_to_many.rb

@@ -1,38 +1,7 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
   class HasAndBelongsToMany # :nodoc:
-    class JoinTableResolver # :nodoc:
-      KnownTable = Struct.new :join_table
-
-      class KnownClass # :nodoc:
-        def initialize(lhs_class, rhs_class_name)
-          @lhs_class      = lhs_class
-          @rhs_class_name = rhs_class_name
-          @join_table     = nil
-        end
-
-        def join_table
-          @join_table ||= [@lhs_class.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
-        end
-
-        private
-
-        def klass
-          @lhs_class.send(:compute_type, @rhs_class_name)
-        end
-      end
-
-      def self.build(lhs_class, name, options)
-        if options[:join_table]
-          KnownTable.new options[:join_table].to_s
-        else
-          class_name = options.fetch(:class_name) {
-            name.to_s.camelize.singularize
-          }
-          KnownClass.new lhs_class, class_name
-        end
-      end
-    end
-
     attr_reader :lhs_model, :association_name, :options
 
     def initialize(association_name, lhs_model, options)
@@ -42,10 +11,8 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def through_model
-      habtm = JoinTableResolver.build lhs_model, association_name, options
-
       join_model = Class.new(ActiveRecord::Base) {
-        class << self;
+        class << self
           attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
@@ -54,7 +21,9 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
 
         def self.table_name
-          table_name_resolver.join_table
+          # Table name needs to be resolved lazily
+          # because RHS class might not have been loaded
+          @table_name ||= table_name_resolver.call
         end
 
         def self.compute_type(class_name)
@@ -77,14 +46,13 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
 
         private
-
-        def self.suppress_composite_primary_key(pk)
-          pk unless pk.is_a?(Array)
-        end
+          def self.suppress_composite_primary_key(pk)
+            pk unless pk.is_a?(Array)
+          end
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
-      join_model.table_name_resolver = habtm
+      join_model.table_name_resolver = -> { table_name }
       join_model.left_model          = lhs_model
 
       join_model.add_left_association :left_side, anonymous_class: lhs_model
@@ -94,7 +62,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def middle_reflection(join_model)
       middle_name = [lhs_model.name.downcase.pluralize,
-                     association_name].join('_'.freeze).gsub('::'.freeze, '_'.freeze).to_sym
+                     association_name.to_s].sort.join("_").gsub("::", "_").to_sym
       middle_options = middle_options join_model
 
       HasMany.create_reflection(lhs_model,
@@ -104,30 +72,41 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     private
+      def middle_options(join_model)
+        middle_options = {}
+        middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
+        middle_options[:source] = join_model.left_reflection.name
+        if options.key? :foreign_key
+          middle_options[:foreign_key] = options[:foreign_key]
+        end
+        middle_options
+      end
 
-    def middle_options(join_model)
-      middle_options = {}
-      middle_options[:class_name] = "#{lhs_model.name}::#{join_model.name}"
-      middle_options[:source] = join_model.left_reflection.name
-      if options.key? :foreign_key
-        middle_options[:foreign_key] = options[:foreign_key]
+      def table_name
+        if options[:join_table]
+          options[:join_table].to_s
+        else
+          class_name = options.fetch(:class_name) {
+            association_name.to_s.camelize.singularize
+          }
+          klass = lhs_model.send(:compute_type, class_name.to_s)
+          [lhs_model.table_name, klass.table_name].sort.join("\0").gsub(/^(.*[._])(.+)\0\1(.+)/, '\1\2_\3').tr("\0", "_")
+        end
       end
-      middle_options
-    end
 
-    def belongs_to_options(options)
-      rhs_options = {}
+      def belongs_to_options(options)
+        rhs_options = {}
 
-      if options.key? :class_name
-        rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
-        rhs_options[:class_name] = options[:class_name]
-      end
+        if options.key? :class_name
+          rhs_options[:foreign_key] = options[:class_name].to_s.foreign_key
+          rhs_options[:class_name] = options[:class_name]
+        end
 
-      if options.key? :association_foreign_key
-        rhs_options[:foreign_key] = options[:association_foreign_key]
-      end
+        if options.key? :association_foreign_key
+          rhs_options[:foreign_key] = options[:association_foreign_key]
+        end
 
-      rhs_options
-    end
+        rhs_options
+      end
   end
 end

data/lib/active_record/associations/builder/has_many.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
   class HasMany < CollectionAssociation #:nodoc:
     def self.macro
@@ -11,5 +13,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     def self.valid_dependent_options
       [:destroy, :delete_all, :nullify, :restrict_with_error, :restrict_with_exception]
     end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options
   end
 end

data/lib/active_record/associations/builder/has_one.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord::Associations::Builder # :nodoc:
   class HasOne < SingularAssociation #:nodoc:
     def self.macro
@@ -5,7 +7,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.valid_options(options)
-      valid = super + [:as]
+      valid = super + [:as, :touch]
       valid += [:through, :source, :source_type] if options[:through]
       valid
     end
@@ -14,6 +16,11 @@ module ActiveRecord::Associations::Builder # :nodoc:
       [:destroy, :delete, :nullify, :restrict_with_error, :restrict_with_exception]
     end
 
+    def self.define_callbacks(model, reflection)
+      super
+      add_touch_callbacks(model, reflection) if reflection.options[:touch]
+    end
+
     def self.add_destroy_callbacks(model, reflection)
       super unless reflection.options[:through]
     end
@@ -24,5 +31,34 @@ module ActiveRecord::Associations::Builder # :nodoc:
         model.validates_presence_of reflection.name, message: :required
       end
     end
+
+    def self.touch_record(o, name, touch)
+      record = o.send name
+
+      return unless record && record.persisted?
+
+      if touch != true
+        record.touch(touch)
+      else
+        record.touch
+      end
+    end
+
+    def self.add_touch_callbacks(model, reflection)
+      name  = reflection.name
+      touch = reflection.options[:touch]
+
+      callback = lambda { |record|
+        HasOne.touch_record(record, name, touch)
+      }
+
+      model.after_create callback, if: :saved_changes?
+      model.after_update callback, if: :saved_changes?
+      model.after_destroy callback
+      model.after_touch callback
+    end
+
+    private_class_method :macro, :valid_options, :valid_dependent_options, :add_destroy_callbacks,
+      :define_callbacks, :define_validations, :add_touch_callbacks
   end
 end

data/lib/active_record/associations/builder/singular_association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class is inherited by the has_one and belongs_to association classes
 
 module ActiveRecord::Associations::Builder # :nodoc:
@@ -36,5 +38,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
         end
       CODE
     end
+
+    private_class_method :valid_options, :define_accessors, :define_constructors
   end
 end

data/lib/active_record/associations/collection_association.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Associations
     # = Active Record Association Collection
@@ -10,9 +12,9 @@ module ActiveRecord
     #     HasManyAssociation => has_many
     #       HasManyThroughAssociation + ThroughAssociation => has_many :through
     #
-    # CollectionAssociation class provides common methods to the collections
+    # The CollectionAssociation class provides common methods to the collections
     # defined by +has_and_belongs_to_many+, +has_many+ or +has_many+ with
-    # +:through association+ option.
+    # the +:through association+ option.
     #
     # You need to be careful with assumptions regarding the target: The proxy
     # does not fetch records from the database until it needs them, but new
@@ -24,18 +26,9 @@ module ActiveRecord
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
     class CollectionAssociation < Association #:nodoc:
-
       # Implements the reader method, e.g. foo.items for Foo.has_many :items
-      def reader(force_reload = false)
-        if force_reload
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Passing an argument to force an association to reload is now
-            deprecated and will be removed in Rails 5.1. Please call `reload`
-            on the result collection proxy instead.
-          MSG
-
-          klass.uncached { reload }
-        elsif stale_target?
+      def reader
+        if stale_target?
           reload
         end
 
@@ -51,30 +44,29 @@ module ActiveRecord
       # Implements the ids reader method, e.g. foo.item_ids for Foo.has_many :items
       def ids_reader
         if loaded?
-          load_target.map do |record|
-            record.send(reflection.association_primary_key)
-          end
+          target.pluck(reflection.association_primary_key)
+        elsif !target.empty?
+          load_target.pluck(reflection.association_primary_key)
         else
-          @association_ids ||= (
-            column = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
-            scope.pluck(column)
-          )
+          @association_ids ||= scope.pluck(reflection.association_primary_key)
         end
       end
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_type = reflection.association_primary_key_type
+        primary_key = reflection.association_primary_key
+        pk_type = klass.type_for_attribute(primary_key)
         ids = Array(ids).reject(&:blank?)
         ids.map! { |i| pk_type.cast(i) }
 
-        primary_key = reflection.association_primary_key
         records = klass.where(primary_key => ids).index_by do |r|
           r.public_send(primary_key)
         end.values_at(*ids).compact
 
         if records.size != ids.size
-          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key)
+          found_ids = records.map { |record| record.public_send(primary_key) }
+          not_found_ids = ids - found_ids
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
         else
           replace(records)
         end
@@ -83,80 +75,29 @@ module ActiveRecord
       def reset
         super
         @target = []
-      end
-
-      def select(*fields)
-        if block_given?
-          load_target.select.each { |e| yield e }
-        else
-          scope.select(*fields)
-        end
+        @association_ids = nil
       end
 
       def find(*args)
-        if block_given?
-          load_target.find(*args) { |*block_args| yield(*block_args) }
-        else
-          if options[:inverse_of] && loaded?
-            args_flatten = args.flatten
-            raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args_flatten.blank?
-            result = find_by_scan(*args)
-
-            result_size = Array(result).size
-            if !result || result_size != args_flatten.size
-              scope.raise_record_not_found_exception!(args_flatten, result_size, args_flatten.size)
-            else
-              result
-            end
-          else
-            scope.find(*args)
-          end
-        end
-      end
-
-      def first(*args)
-        first_nth_or_last(:first, *args)
-      end
-
-      def second(*args)
-        first_nth_or_last(:second, *args)
-      end
-
-      def third(*args)
-        first_nth_or_last(:third, *args)
-      end
-
-      def fourth(*args)
-        first_nth_or_last(:fourth, *args)
-      end
-
-      def fifth(*args)
-        first_nth_or_last(:fifth, *args)
-      end
-
-      def forty_two(*args)
-        first_nth_or_last(:forty_two, *args)
-      end
-
-      def third_to_last(*args)
-        first_nth_or_last(:third_to_last, *args)
-      end
+        if options[:inverse_of] && loaded?
+          args_flatten = args.flatten
+          model = scope.klass
 
-      def second_to_last(*args)
-        first_nth_or_last(:second_to_last, *args)
-      end
+          if args_flatten.blank?
+            error_message = "Couldn't find #{model.name} without an ID"
+            raise RecordNotFound.new(error_message, model.name, model.primary_key, args)
+          end
 
-      def last(*args)
-        first_nth_or_last(:last, *args)
-      end
+          result = find_by_scan(*args)
 
-      def take(n = nil)
-        if loaded?
-          n ? target.take(n) : target.first
-        else
-          scope.take(n).tap do |record|
-            set_inverse_instance record if record.is_a? ActiveRecord::Base
+          result_size = Array(result).size
+          if !result || result_size != args_flatten.size
+            scope.raise_record_not_found_exception!(args_flatten, result_size, args_flatten.size)
+          else
+            result
           end
+        else
+          scope.find(*args)
         end
       end
 
@@ -164,23 +105,12 @@ module ActiveRecord
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
         else
-          add_to_target(build_record(attributes)) do |record|
-            yield(record) if block_given?
-          end
+          add_to_target(build_record(attributes, &block))
         end
       end
 
-      def create(attributes = {}, &block)
-        _create_record(attributes, &block)
-      end
-
-      def create!(attributes = {}, &block)
-        _create_record(attributes, true, &block)
-      end
-
-      # Add +records+ to this association. Returns +self+ so method calls may
-      # be chained. Since << flattens its argument list and inserts each record,
-      # +push+ and +concat+ behave identically.
+      # Add +records+ to this association. Since +<<+ flattens its argument list
+      # and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
         records = records.flatten
         if owner.new_record?
@@ -225,12 +155,12 @@ module ActiveRecord
         end
 
         dependent = if dependent
-                      dependent
-                    elsif options[:dependent] == :destroy
-                      :delete_all
-                    else
-                      options[:dependent]
-                    end
+          dependent
+        elsif options[:dependent] == :destroy
+          :delete_all
+        else
+          options[:dependent]
+        end
 
         delete_or_nullify_all_records(dependent).tap do
           reset
@@ -248,28 +178,6 @@ module ActiveRecord
         end
       end
 
-      # Count all records using SQL.  Construct options and pass them with
-      # scope to the target class's +count+.
-      def count(column_name = nil)
-        relation = scope
-        if association_scope.distinct_value
-          # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-          column_name ||= reflection.klass.primary_key
-          relation = relation.distinct
-        end
-
-        value = relation.count(column_name)
-
-        limit  = options[:limit]
-        offset = options[:offset]
-
-        if limit || offset
-          [ [value - offset.to_i, 0].max, limit.to_i ].min
-        else
-          value
-        end
-      end
-
       # Removes +records+ from this association calling +before_remove+ and
       # +after_remove+ callbacks.
       #
@@ -278,12 +186,7 @@ module ActiveRecord
       # are actually removed from the database, that depends precisely on
       # +delete_records+. They are in any case removed from the collection.
       def delete(*records)
-        return if records.empty?
-        _options = records.extract_options!
-        dependent = _options[:dependent] || options[:dependent]
-
-        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
-        delete_or_destroy(records, dependent)
+        delete_or_destroy(records, options[:dependent])
       end
 
       # Deletes the +records+ and removes them from this association calling
@@ -292,8 +195,6 @@ module ActiveRecord
       # Note that this method removes records from the database ignoring the
       # +:dependent+ option.
       def destroy(*records)
-        return if records.empty?
-        records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
         delete_or_destroy(records, :destroy)
       end
 
@@ -309,14 +210,12 @@ module ActiveRecord
       # +count_records+, which is a method descendants have to provide.
       def size
         if !find_target? || loaded?
-          if association_scope.distinct_value
-            target.uniq.size
-          else
-            target.size
-          end
+          target.size
+        elsif @association_ids
+          @association_ids.size
         elsif !association_scope.group_values.empty?
           load_target.size
-        elsif !association_scope.distinct_value && target.is_a?(Array)
+        elsif !association_scope.distinct_value && !target.empty?
           unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
@@ -324,15 +223,6 @@ module ActiveRecord
         end
       end
 
-      # Returns the size of the collection calling +size+ on the target.
-      #
-      # If the collection has been already loaded +length+ and +size+ are
-      # equivalent. If not and you are going to need the records anyway this
-      # method will take one less query. Otherwise +size+ is more efficient.
-      def length
-        load_target.size
-      end
-
       # Returns true if the collection is empty.
       #
       # If the collection has been loaded
@@ -342,42 +232,12 @@ module ActiveRecord
       # loaded and you are going to fetch the records anyway it is better to
       # check <tt>collection.length.zero?</tt>.
       def empty?
-        if loaded?
+        if loaded? || @association_ids || reflection.has_cached_counter?
           size.zero?
         else
-          @target.blank? && !scope.exists?
-        end
-      end
-
-      # Returns true if the collections is not empty.
-      # If block given, loads all records and checks for one or more matches.
-      # Otherwise, equivalent to +!collection.empty?+.
-      def any?
-        if block_given?
-          load_target.any? { |*block_args| yield(*block_args) }
-        else
-          !empty?
-        end
-      end
-
-      # Returns true if the collection has more than 1 record.
-      # If block given, loads all records and checks for two or more matches.
-      # Otherwise, equivalent to +collection.size > 1+.
-      def many?
-        if block_given?
-          load_target.many? { |*block_args| yield(*block_args) }
-        else
-          size > 1
-        end
-      end
-
-      def distinct
-        seen = {}
-        load_target.find_all do |record|
-          seen[record.id] = true unless seen.key?(record.id)
+          target.empty? && !scope.exists?
         end
       end
-      alias uniq distinct
 
       # Replace this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
@@ -435,28 +295,13 @@ module ActiveRecord
         owner.new_record? && !foreign_key_present?
       end
 
-      private
-      def get_records(&block)
-        return scope.to_a if skip_statement_cache?
-
-        conn = klass.connection
-        sc = reflection.association_scope_cache(conn, owner) do
-          StatementCache.create(conn) { |params|
-            as = AssociationScope.create { params.bind }
-            target_scope.merge as.scope(self, conn)
-          }
-        end
-
-        binds = AssociationScope.get_bind_values(owner, reflection.chain)
-        sc.execute(binds, klass, klass.connection, &block)
+      def find_from_target?
+        loaded? ||
+          owner.new_record? ||
+          target.any? { |record| record.new_record? || record.changed? }
       end
 
-        def find_target
-          get_records do |record|
-            set_inverse_instance(record)
-          end
-        end
-
+      private
         # We have some records loaded from the database (persisted) and some that are
         # in-memory (memory). The same record may be represented in the persisted array
         # and in the memory array.
@@ -474,7 +319,7 @@ module ActiveRecord
           persisted.map! do |record|
             if mem_record = memory.delete(record)
 
-              ((record.attribute_names & mem_record.attribute_names) - mem_record.changes.keys).each do |name|
+              ((record.attribute_names & mem_record.attribute_names) - mem_record.changed_attribute_names_to_save).each do |name|
                 mem_record[name] = record[name]
               end
 
@@ -495,12 +340,17 @@ module ActiveRecord
           if attributes.is_a?(Array)
             attributes.collect { |attr| _create_record(attr, raise, &block) }
           else
+            record = build_record(attributes, &block)
             transaction do
-              add_to_target(build_record(attributes)) do |record|
-                yield(record) if block_given?
-                insert_record(record, true, raise) { @_was_loaded = loaded? }
+              result = nil
+              add_to_target(record) do
+                result = insert_record(record, true, raise) {
+                  @_was_loaded = loaded?
+                }
               end
+              raise ActiveRecord::Rollback unless result
             end
+            record
           end
         end
 
@@ -513,11 +363,9 @@ module ActiveRecord
           end
         end
 
-        def create_scope
-          scope.scope_for_create.stringify_keys
-        end
-
         def delete_or_destroy(records, method)
+          return if records.empty?
+          records = find(records) if records.any? { |record| record.kind_of?(Integer) || record.kind_of?(String) }
           records = records.flatten
           records.each { |record| raise_on_type_mismatch!(record) }
           existing_records = records.reject(&:new_record?)
@@ -530,24 +378,28 @@ module ActiveRecord
         end
 
         def remove_records(existing_records, records, method)
-          records.each { |record| callback(:before_remove, record) }
+          catch(:abort) do
+            records.each { |record| callback(:before_remove, record) }
+          end || return
 
           delete_records(existing_records, method) if existing_records.any?
-          records.each { |record| target.delete(record) }
+          @target -= records
+          @association_ids = nil
 
           records.each { |record| callback(:after_remove, record) }
         end
 
-        # Delete the given records from the association, using one of the methods :destroy,
-        # :delete_all or :nullify (or nil, in which case a default is used).
+        # Delete the given records from the association,
+        # using one of the methods +:destroy+, +:delete_all+
+        # or +:nullify+ (or +nil+, in which case a default is used).
         def delete_records(records, method)
           raise NotImplementedError
         end
 
         def replace_records(new_target, original_target)
-          delete(target - new_target)
+          delete(difference(target, new_target))
 
-          unless concat(new_target - target)
+          unless concat(difference(new_target, target))
             @target = original_target
             raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
                                   "new records could not be saved."
@@ -557,7 +409,7 @@ module ActiveRecord
         end
 
         def replace_common_records_in_memory(new_target, original_target)
-          common_records = new_target & original_target
+          common_records = intersection(new_target, original_target)
           common_records.each do |record|
             skip_callbacks = true
             replace_on_target(record, @target.index(record), skip_callbacks)
@@ -570,15 +422,23 @@ module ActiveRecord
           records.each do |record|
             raise_on_type_mismatch!(record)
             add_to_target(record) do
-              result &&= insert_record(record, true, raise) { @_was_loaded = loaded? } unless owner.new_record?
+              unless owner.new_record?
+                result &&= insert_record(record, true, raise) {
+                  @_was_loaded = loaded?
+                }
+              end
             end
           end
 
-          result && records
+          raise ActiveRecord::Rollback unless result
+
+          records
         end
 
         def replace_on_target(record, index, skip_callbacks)
-          callback(:before_add, record) unless skip_callbacks
+          catch(:abort) do
+            callback(:before_add, record)
+          end || return unless skip_callbacks
 
           set_inverse_instance(record)
 
@@ -589,6 +449,7 @@ module ActiveRecord
           if index
             target[index] = record
           elsif @_was_loaded || !loaded?
+            @association_ids = nil
             target << record
           end
 
@@ -610,25 +471,6 @@ module ActiveRecord
           owner.class.send(full_callback_name)
         end
 
-        # Should we deal with assoc.first or assoc.last by issuing an independent query to
-        # the database, or by getting the target, and then taking the first/last item from that?
-        #
-        # If the args is just a non-empty options hash, go to the database.
-        #
-        # Otherwise, go to the database only if none of the following are true:
-        #   * target already loaded
-        #   * owner is new record
-        #   * target contains new or changed record(s)
-        def fetch_first_nth_or_last_using_find?(args)
-          if args.first.is_a?(Hash)
-            true
-          else
-            !(loaded? ||
-              owner.new_record? ||
-              target.any? { |record| record.new_record? || record.changed? })
-          end
-        end
-
         def include_in_memory?(record)
           if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
             assoc = owner.association(reflection.through_reflection.name)
@@ -655,16 +497,6 @@ module ActiveRecord
             load_target.select { |r| ids.include?(r.id.to_s) }
           end
         end
-
-        # Fetches the first/last using SQL if possible, otherwise from the target array.
-        def first_nth_or_last(type, *args)
-          args.shift if args.first.is_a?(Hash) && args.first.empty?
-
-          collection = fetch_first_nth_or_last_using_find?(args) ? scope : load_target
-          collection.send(type, *args).tap do |record|
-            set_inverse_instance record if record.is_a? ActiveRecord::Base
-          end
-        end
     end
   end
 end