activerecord 5.0.7 → 5.1.7

data/lib/active_record/associations/preloader/association.rb

@@ -28,10 +28,6 @@ module ActiveRecord
         end
 
         def records_for(ids)
-          query_scope(ids)
-        end
-
-        def query_scope(ids)
           scope.where(association_key_name => ids)
         end
 
@@ -61,86 +57,90 @@ module ActiveRecord
 
         private
 
-        def associated_records_by_owner(preloader)
-          records = load_records do |record|
-            owner = owners_by_key[convert_key(record[association_key_name])]
-            association = owner.association(reflection.name)
-            association.set_inverse_instance(record)
-          end
+          def associated_records_by_owner(preloader)
+            records = load_records do |record|
+              owner = owners_by_key[convert_key(record[association_key_name])]
+              association = owner.association(reflection.name)
+              association.set_inverse_instance(record)
+            end
 
-          owners.each_with_object({}) do |owner, result|
-            result[owner] = records[convert_key(owner[owner_key_name])] || []
+            owners.each_with_object({}) do |owner, result|
+              result[owner] = records[convert_key(owner[owner_key_name])] || []
+            end
           end
-        end
 
-        def owner_keys
-          unless defined?(@owner_keys)
-            @owner_keys = owners.map do |owner|
-              owner[owner_key_name]
+          def owner_keys
+            unless defined?(@owner_keys)
+              @owner_keys = owners.map do |owner|
+                owner[owner_key_name]
+              end
+              @owner_keys.uniq!
+              @owner_keys.compact!
             end
-            @owner_keys.uniq!
-            @owner_keys.compact!
+            @owner_keys
           end
-          @owner_keys
-        end
 
-        def owners_by_key
-          unless defined?(@owners_by_key)
-            @owners_by_key = owners.each_with_object({}) do |owner, h|
-              h[convert_key(owner[owner_key_name])] = owner
+          def owners_by_key
+            unless defined?(@owners_by_key)
+              @owners_by_key = owners.each_with_object({}) do |owner, h|
+                h[convert_key(owner[owner_key_name])] = owner
+              end
             end
+            @owners_by_key
           end
-          @owners_by_key
-        end
 
-        def key_conversion_required?
-          @key_conversion_required ||= association_key_type != owner_key_type
-        end
+          def key_conversion_required?
+            unless defined?(@key_conversion_required)
+              @key_conversion_required = (association_key_type != owner_key_type)
+            end
 
-        def convert_key(key)
-          if key_conversion_required?
-            key.to_s
-          else
-            key
+            @key_conversion_required
           end
-        end
 
-        def association_key_type
-          @klass.type_for_attribute(association_key_name.to_s).type
-        end
+          def convert_key(key)
+            if key_conversion_required?
+              key.to_s
+            else
+              key
+            end
+          end
 
-        def owner_key_type
-          @model.type_for_attribute(owner_key_name.to_s).type
-        end
+          def association_key_type
+            @klass.type_for_attribute(association_key_name.to_s).type
+          end
 
-        def load_records(&block)
-          return {} if owner_keys.empty?
-          # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
-          # Make several smaller queries if necessary or make one query if the adapter supports it
-          slices  = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
-          @preloaded_records = slices.flat_map do |slice|
-            records_for(slice).load(&block)
+          def owner_key_type
+            @model.type_for_attribute(owner_key_name.to_s).type
           end
-          @preloaded_records.group_by do |record| 
-            convert_key(record[association_key_name])
+
+          def load_records(&block)
+            return {} if owner_keys.empty?
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            slices = owner_keys.each_slice(klass.connection.in_clause_length || owner_keys.size)
+            @preloaded_records = slices.flat_map do |slice|
+              records_for(slice).load(&block)
+            end
+            @preloaded_records.group_by do |record|
+              convert_key(record[association_key_name])
+            end
           end
-        end
 
-        def reflection_scope
-          @reflection_scope ||= reflection.scope_for(klass)
-        end
+          def reflection_scope
+            @reflection_scope ||= reflection.scope_for(klass)
+          end
 
-        def build_scope
-          scope = klass.scope_for_association
+          def build_scope
+            scope = klass.scope_for_association
 
-          if reflection.type
-            scope.where!(reflection.type => model.base_class.sti_name)
-          end
+            if reflection.type
+              scope.where!(reflection.type => model.base_class.sti_name)
+            end
 
-          scope.merge!(reflection_scope)
-          scope.merge!(preload_scope) if preload_scope != NULL_RELATION
-          scope
-        end
+            scope.merge!(reflection_scope)
+            scope.merge!(preload_scope) if preload_scope != NULL_RELATION
+            scope
+          end
       end
     end
   end

data/lib/active_record/associations/preloader/belongs_to.rb

@@ -2,7 +2,6 @@ module ActiveRecord
   module Associations
     class Preloader
       class BelongsTo < SingularAssociation #:nodoc:
-
         def association_key_name
           reflection.options[:primary_key] || klass && klass.primary_key
         end
@@ -10,7 +9,6 @@ module ActiveRecord
         def owner_key_name
           reflection.foreign_key
         end
-
       end
     end
   end

data/lib/active_record/associations/preloader/collection_association.rb

@@ -4,13 +4,13 @@ module ActiveRecord
       class CollectionAssociation < Association #:nodoc:
         private
 
-        def preload(preloader)
-          associated_records_by_owner(preloader).each do |owner, records|
-            association = owner.association(reflection.name)
-            association.loaded!
-            association.target.concat(records)
+          def preload(preloader)
+            associated_records_by_owner(preloader).each do |owner, records|
+              association = owner.association(reflection.name)
+              association.loaded!
+              association.target.concat(records)
+            end
           end
-        end
       end
     end
   end

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

@@ -2,7 +2,6 @@ module ActiveRecord
   module Associations
     class Preloader
       class HasMany < CollectionAssociation #:nodoc:
-
         def association_key_name
           reflection.foreign_key
         end
@@ -10,7 +9,6 @@ module ActiveRecord
         def owner_key_name
           reflection.active_record_primary_key
         end
-
       end
     end
   end

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

@@ -2,18 +2,16 @@ module ActiveRecord
   module Associations
     class Preloader
       class SingularAssociation < Association #:nodoc:
-
         private
 
-        def preload(preloader)
-          associated_records_by_owner(preloader).each do |owner, associated_records|
-            record = associated_records.first
+          def preload(preloader)
+            associated_records_by_owner(preloader).each do |owner, associated_records|
+              record = associated_records.first
 
-            association = owner.association(reflection.name)
-            association.target = record
+              association = owner.association(reflection.name)
+              association.target = record
+            end
           end
-        end
-
       end
     end
   end

data/lib/active_record/associations/preloader/through_association.rb

@@ -24,7 +24,7 @@ module ActiveRecord
 
           reset_association owners, through_reflection.name
 
-          middle_records = through_records.flat_map { |(_,rec)| rec }
+          middle_records = through_records.flat_map { |(_, rec)| rec }
 
           preloaders = preloader.preload(middle_records,
                                          source_reflection.name,
@@ -32,13 +32,13 @@ module ActiveRecord
 
           @preloaded_records = preloaders.flat_map(&:preloaded_records)
 
-          middle_to_pl = preloaders.each_with_object({}) do |pl,h|
+          middle_to_pl = preloaders.each_with_object({}) do |pl, h|
             pl.owners.each { |middle|
               h[middle] = pl
             }
           end
 
-          through_records.each_with_object({}) do |(lhs,center), records_by_owner|
+          through_records.each_with_object({}) do |(lhs, center), records_by_owner|
             pl_to_middle = center.group_by { |record| middle_to_pl[record] }
 
             records_by_owner[lhs] = pl_to_middle.flat_map do |pl, middles|
@@ -61,54 +61,54 @@ module ActiveRecord
 
         private
 
-        def id_to_index_map(ids)
-          id_map = {}
-          ids.each_with_index { |id, index| id_map[id] = index }
-          id_map
-        end
+          def id_to_index_map(ids)
+            id_map = {}
+            ids.each_with_index { |id, index| id_map[id] = index }
+            id_map
+          end
 
-        def reset_association(owners, association_name)
-          should_reset = (through_scope != through_reflection.klass.unscoped) ||
-             (reflection.options[:source_type] && through_reflection.collection?)
+          def reset_association(owners, association_name)
+            should_reset = (through_scope != through_reflection.klass.unscoped) ||
+               (reflection.options[:source_type] && through_reflection.collection?)
 
-          # Don't cache the association - we would only be caching a subset
-          if should_reset
-            owners.each { |owner|
-              owner.association(association_name).reset
-            }
+            # Don't cache the association - we would only be caching a subset
+            if should_reset
+              owners.each { |owner|
+                owner.association(association_name).reset
+              }
+            end
           end
-        end
 
-        def through_scope
-          scope = through_reflection.klass.unscoped
-          values = reflection_scope.values
-
-          if options[:source_type]
-            scope.where! reflection.foreign_type => options[:source_type]
-          else
-            unless reflection_scope.where_clause.empty?
-              scope.includes_values = Array(values[:includes] || options[:source])
-              scope.where_clause = reflection_scope.where_clause
-              if joins = values[:joins]
-                scope.joins!(source_reflection.name => joins)
+          def through_scope
+            scope = through_reflection.klass.unscoped
+            values = reflection_scope.values
+
+            if options[:source_type]
+              scope.where! reflection.foreign_type => options[:source_type]
+            else
+              unless reflection_scope.where_clause.empty?
+                scope.includes_values = Array(values[:includes] || options[:source])
+                scope.where_clause = reflection_scope.where_clause
+                if joins = values[:joins]
+                  scope.joins!(source_reflection.name => joins)
+                end
+                if left_outer_joins = values[:left_outer_joins]
+                  scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+                end
               end
-              if left_outer_joins = values[:left_outer_joins]
-                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+
+              scope.references! values[:references]
+              if scope.eager_loading? && order_values = values[:order]
+                scope = scope.order(order_values)
               end
             end
 
-            scope.references! values[:references]
-            if scope.eager_loading? && order_values = values[:order]
-              scope = scope.order(order_values)
-            end
+            scope
           end
 
-          scope
-        end
-
-        def target_records_from_association(association)
-          association.loaded? ? association.target : association.reader
-        end
+          def target_records_from_association(association)
+            association.loaded? ? association.target : association.reader
+          end
       end
     end
   end

data/lib/active_record/associations/preloader.rb

@@ -42,16 +42,16 @@ module ActiveRecord
       extend ActiveSupport::Autoload
 
       eager_autoload do
-        autoload :Association,           'active_record/associations/preloader/association'
-        autoload :SingularAssociation,   'active_record/associations/preloader/singular_association'
-        autoload :CollectionAssociation, 'active_record/associations/preloader/collection_association'
-        autoload :ThroughAssociation,    'active_record/associations/preloader/through_association'
-
-        autoload :HasMany,             'active_record/associations/preloader/has_many'
-        autoload :HasManyThrough,      'active_record/associations/preloader/has_many_through'
-        autoload :HasOne,              'active_record/associations/preloader/has_one'
-        autoload :HasOneThrough,       'active_record/associations/preloader/has_one_through'
-        autoload :BelongsTo,           'active_record/associations/preloader/belongs_to'
+        autoload :Association,           "active_record/associations/preloader/association"
+        autoload :SingularAssociation,   "active_record/associations/preloader/singular_association"
+        autoload :CollectionAssociation, "active_record/associations/preloader/collection_association"
+        autoload :ThroughAssociation,    "active_record/associations/preloader/through_association"
+
+        autoload :HasMany,             "active_record/associations/preloader/has_many"
+        autoload :HasManyThrough,      "active_record/associations/preloader/has_many_through"
+        autoload :HasOne,              "active_record/associations/preloader/has_one"
+        autoload :HasOneThrough,       "active_record/associations/preloader/has_one_through"
+        autoload :BelongsTo,           "active_record/associations/preloader/belongs_to"
       end
 
       NULL_RELATION = Struct.new(:values, :where_clause, :joins_values).new({}, Relation::WhereClause.empty, [])
@@ -106,108 +106,108 @@ module ActiveRecord
 
       private
 
-      # Loads all the given data into +records+ for the +association+.
-      def preloaders_on(association, records, scope)
-        case association
-        when Hash
-          preloaders_for_hash(association, records, scope)
-        when Symbol
-          preloaders_for_one(association, records, scope)
-        when String
-          preloaders_for_one(association.to_sym, records, scope)
-        else
-          raise ArgumentError, "#{association.inspect} was not recognized for preload"
+        # Loads all the given data into +records+ for the +association+.
+        def preloaders_on(association, records, scope)
+          case association
+          when Hash
+            preloaders_for_hash(association, records, scope)
+          when Symbol
+            preloaders_for_one(association, records, scope)
+          when String
+            preloaders_for_one(association.to_sym, records, scope)
+          else
+            raise ArgumentError, "#{association.inspect} was not recognized for preload"
+          end
         end
-      end
 
-      def preloaders_for_hash(association, records, scope)
-        association.flat_map { |parent, child|
-          loaders = preloaders_for_one parent, records, scope
+        def preloaders_for_hash(association, records, scope)
+          association.flat_map { |parent, child|
+            loaders = preloaders_for_one parent, records, scope
 
-          recs = loaders.flat_map(&:preloaded_records).uniq
-          loaders.concat Array.wrap(child).flat_map { |assoc|
-            preloaders_on assoc, recs, scope
+            recs = loaders.flat_map(&:preloaded_records).uniq
+            loaders.concat Array.wrap(child).flat_map { |assoc|
+              preloaders_on assoc, recs, scope
+            }
+            loaders
           }
-          loaders
-        }
-      end
+        end
 
-      # Loads all the given data into +records+ for a singular +association+.
-      #
-      # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
-      # call the +run+ method for each passed in class in the +records+ argument.
-      #
-      # Not all records have the same class, so group then preload group on the reflection
-      # itself so that if various subclass share the same association then we do not split
-      # them unnecessarily
-      #
-      # Additionally, polymorphic belongs_to associations can have multiple associated
-      # classes, depending on the polymorphic_type field. So we group by the classes as
-      # well.
-      def preloaders_for_one(association, records, scope)
-        grouped_records(association, records).flat_map do |reflection, klasses|
-          klasses.map do |rhs_klass, rs|
-            loader = preloader_for(reflection, rs, rhs_klass).new(rhs_klass, rs, reflection, scope)
-            loader.run self
-            loader
+        # Loads all the given data into +records+ for a singular +association+.
+        #
+        # Functions by instantiating a preloader class such as Preloader::HasManyThrough and
+        # call the +run+ method for each passed in class in the +records+ argument.
+        #
+        # Not all records have the same class, so group then preload group on the reflection
+        # itself so that if various subclass share the same association then we do not split
+        # them unnecessarily
+        #
+        # Additionally, polymorphic belongs_to associations can have multiple associated
+        # classes, depending on the polymorphic_type field. So we group by the classes as
+        # well.
+        def preloaders_for_one(association, records, scope)
+          grouped_records(association, records).flat_map do |reflection, klasses|
+            klasses.map do |rhs_klass, rs|
+              loader = preloader_for(reflection, rs, rhs_klass).new(rhs_klass, rs, reflection, scope)
+              loader.run self
+              loader
+            end
           end
         end
-      end
 
-      def grouped_records(association, records)
-        h = {}
-        records.each do |record|
-          next unless record
-          assoc = record.association(association)
-          klasses = h[assoc.reflection] ||= {}
-          (klasses[assoc.klass] ||= []) << record
+        def grouped_records(association, records)
+          h = {}
+          records.each do |record|
+            next unless record
+            assoc = record.association(association)
+            klasses = h[assoc.reflection] ||= {}
+            (klasses[assoc.klass] ||= []) << record
+          end
+          h
         end
-        h
-      end
 
-      class AlreadyLoaded # :nodoc:
-        attr_reader :owners, :reflection
+        class AlreadyLoaded # :nodoc:
+          attr_reader :owners, :reflection
 
-        def initialize(klass, owners, reflection, preload_scope)
-          @owners = owners
-          @reflection = reflection
-        end
+          def initialize(klass, owners, reflection, preload_scope)
+            @owners = owners
+            @reflection = reflection
+          end
 
-        def run(preloader); end
+          def run(preloader); end
 
-        def preloaded_records
-          owners.flat_map { |owner| owner.association(reflection.name).target }
+          def preloaded_records
+            owners.flat_map { |owner| owner.association(reflection.name).target }
+          end
         end
-      end
 
-      class NullPreloader # :nodoc:
-        def self.new(klass, owners, reflection, preload_scope); self; end
-        def self.run(preloader); end
-        def self.preloaded_records; []; end
-        def self.owners; []; end
-      end
+        class NullPreloader # :nodoc:
+          def self.new(klass, owners, reflection, preload_scope); self; end
+          def self.run(preloader); end
+          def self.preloaded_records; []; end
+          def self.owners; []; end
+        end
 
-      # Returns a class containing the logic needed to load preload the data
-      # and attach it to a relation. For example +Preloader::Association+ or
-      # +Preloader::HasManyThrough+. The class returned implements a `run` method
-      # that accepts a preloader.
-      def preloader_for(reflection, owners, rhs_klass)
-        return NullPreloader unless rhs_klass
+        # Returns a class containing the logic needed to load preload the data
+        # and attach it to a relation. For example +Preloader::Association+ or
+        # +Preloader::HasManyThrough+. The class returned implements a `run` method
+        # that accepts a preloader.
+        def preloader_for(reflection, owners, rhs_klass)
+          return NullPreloader unless rhs_klass
 
-        if owners.first.association(reflection.name).loaded?
-          return AlreadyLoaded
-        end
-        reflection.check_preloadable!
-
-        case reflection.macro
-        when :has_many
-          reflection.options[:through] ? HasManyThrough : HasMany
-        when :has_one
-          reflection.options[:through] ? HasOneThrough : HasOne
-        when :belongs_to
-          BelongsTo
+          if owners.first.association(reflection.name).loaded?
+            return AlreadyLoaded
+          end
+          reflection.check_preloadable!
+
+          case reflection.macro
+          when :has_many
+            reflection.options[:through] ? HasManyThrough : HasMany
+          when :has_one
+            reflection.options[:through] ? HasOneThrough : HasOne
+          when :belongs_to
+            BelongsTo
+          end
         end
-      end
     end
   end
 end

data/lib/active_record/associations/singular_association.rb

@@ -2,15 +2,8 @@ module ActiveRecord
   module Associations
     class SingularAssociation < Association #:nodoc:
       # Implements the reader method, e.g. foo.bar for Foo.has_one :bar
-      def reader(force_reload = false)
-        if force_reload && klass
-          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_#{reflection.name}` instead.
-          MSG
-
-          klass.uncached { reload }
-        elsif !loaded? || stale_target?
+      def reader
+        if !loaded? || stale_target?
           reload
         end
 
@@ -22,14 +15,6 @@ module ActiveRecord
         replace(record)
       end
 
-      def create(attributes = {}, &block)
-        _create_record(attributes, &block)
-      end
-
-      def create!(attributes = {}, &block)
-        _create_record(attributes, true, &block)
-      end
-
       def build(attributes = {})
         record = build_record(attributes)
         yield(record) if block_given?
@@ -50,8 +35,8 @@ module ActiveRecord
           scope.scope_for_create.stringify_keys.except(klass.primary_key)
         end
 
-        def get_records
-          return scope.limit(1).records if skip_statement_cache?
+        def find_target
+          return scope.take if skip_statement_cache?
 
           conn = klass.connection
           sc = reflection.association_scope_cache(conn, owner) do
@@ -62,13 +47,11 @@ module ActiveRecord
           end
 
           binds = AssociationScope.get_bind_values(owner, reflection.chain)
-          sc.execute binds, klass, klass.connection
-        end
-
-        def find_target
-          if record = get_records.first
+          sc.execute(binds, klass, conn) do |record|
             set_inverse_instance record
-          end
+          end.first
+        rescue ::RangeError
+          nil
         end
 
         def replace(record)

data/lib/active_record/associations/through_association.rb

@@ -2,10 +2,9 @@ module ActiveRecord
   # = Active Record Through Association
   module Associations
     module ThroughAssociation #:nodoc:
+      delegate :source_reflection, :through_reflection, to: :reflection
 
-      delegate :source_reflection, :through_reflection, :to => :reflection
-
-      protected
+      private
 
         # We merge in these scopes for two reasons:
         #
@@ -22,8 +21,6 @@ module ActiveRecord
           scope
         end
 
-      private
-
         # Construct attributes for :through pointing to owner and associate. This is used by the
         # methods which create and delete records on the association.
         #