activerecord 5.0.7.2 → 5.1.0.beta1

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,47 @@ 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
+
+            if options[:source_type]
+              scope.where! reflection.foreign_type => options[:source_type]
+            else
+              unless reflection_scope.where_clause.empty?
+                scope.includes_values = Array(reflection_scope.values[:includes] || options[:source])
+                scope.where_clause = reflection_scope.where_clause
               end
-              if left_outer_joins = values[:left_outer_joins]
-                scope.left_outer_joins!(source_reflection.name => left_outer_joins)
+
+              scope.references! reflection_scope.values[:references]
+              if scope.eager_loading? && order_values = reflection_scope.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/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:
         #
@@ -14,7 +13,7 @@ module ActiveRecord
         def target_scope
           scope = super
           reflection.chain.drop(1).each do |reflection|
-            relation = reflection.klass.scope_for_association
+            relation = reflection.klass.all
             scope.merge!(
               relation.except(:select, :create_with, :includes, :preload, :joins, :eager_load)
             )
@@ -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.
         #

data/lib/active_record/attribute.rb

@@ -77,7 +77,11 @@ module ActiveRecord
     end
 
     def with_type(type)
-      self.class.new(name, value_before_type_cast, type, original_attribute)
+      if changed_in_place?
+        with_value_from_user(value).with_type(type)
+      else
+        self.class.new(name, value_before_type_cast, type, original_attribute)
+      end
     end
 
     def type_cast(*)
@@ -108,106 +112,129 @@ module ActiveRecord
       [self.class, name, value_before_type_cast, type].hash
     end
 
-    protected
-
-    attr_reader :original_attribute
-    alias_method :assigned?, :original_attribute
-
-    def initialize_dup(other)
-      if defined?(@value) && @value.duplicable?
-        @value = @value.dup
-      end
+    def init_with(coder)
+      @name = coder["name"]
+      @value_before_type_cast = coder["value_before_type_cast"]
+      @type = coder["type"]
+      @original_attribute = coder["original_attribute"]
+      @value = coder["value"] if coder.map.key?("value")
     end
 
-    def changed_from_assignment?
-      assigned? && type.changed?(original_value, value, value_before_type_cast)
+    def encode_with(coder)
+      coder["name"] = name
+      coder["value_before_type_cast"] = value_before_type_cast if value_before_type_cast
+      coder["type"] = type if type
+      coder["original_attribute"] = original_attribute if original_attribute
+      coder["value"] = value if defined?(@value)
     end
 
-    def original_value_for_database
-      if assigned?
-        original_attribute.original_value_for_database
-      else
-        _original_value_for_database
-      end
-    end
+    # TODO Change this to private once we've dropped Ruby 2.2 support.
+    # Workaround for Ruby 2.2 "private attribute?" warning.
+    protected
 
-    def _original_value_for_database
-      type.serialize(original_value)
-    end
+      attr_reader :original_attribute
+      alias_method :assigned?, :original_attribute
 
-    class FromDatabase < Attribute # :nodoc:
-      def type_cast(value)
-        type.deserialize(value)
+      def original_value_for_database
+        if assigned?
+          original_attribute.original_value_for_database
+        else
+          _original_value_for_database
+        end
       end
 
-      def _original_value_for_database
-        value_before_type_cast
+    private
+      def initialize_dup(other)
+        if defined?(@value) && @value.duplicable?
+          @value = @value.dup
+        end
       end
-    end
 
-    class FromUser < Attribute # :nodoc:
-      def type_cast(value)
-        type.cast(value)
+      def changed_from_assignment?
+        assigned? && type.changed?(original_value, value, value_before_type_cast)
       end
 
-      def came_from_user?
-        true
+      def _original_value_for_database
+        type.serialize(original_value)
       end
-    end
 
-    class WithCastValue < Attribute # :nodoc:
-      def type_cast(value)
-        value
-      end
+      class FromDatabase < Attribute # :nodoc:
+        def type_cast(value)
+          type.deserialize(value)
+        end
 
-      def changed_in_place?
-        false
+        def _original_value_for_database
+          value_before_type_cast
+        end
       end
-    end
 
-    class Null < Attribute # :nodoc:
-      def initialize(name)
-        super(name, nil, Type::Value.new)
-      end
+      class FromUser < Attribute # :nodoc:
+        def type_cast(value)
+          type.cast(value)
+        end
 
-      def type_cast(*)
-        nil
+        def came_from_user?
+          true
+        end
       end
 
-      def with_type(type)
-        self.class.with_cast_value(name, nil, type)
-      end
+      class WithCastValue < Attribute # :nodoc:
+        def type_cast(value)
+          value
+        end
 
-      def with_value_from_database(value)
-        raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+        def changed_in_place?
+          false
+        end
       end
-      alias_method :with_value_from_user, :with_value_from_database
-    end
 
-    class Uninitialized < Attribute # :nodoc:
-      UNINITIALIZED_ORIGINAL_VALUE = Object.new
+      class Null < Attribute # :nodoc:
+        def initialize(name)
+          super(name, nil, Type.default_value)
+        end
 
-      def initialize(name, type)
-        super(name, nil, type)
-      end
+        def type_cast(*)
+          nil
+        end
 
-      def value
-        if block_given?
-          yield name
+        def with_type(type)
+          self.class.with_cast_value(name, nil, type)
         end
-      end
 
-      def original_value
-        UNINITIALIZED_ORIGINAL_VALUE
+        def with_value_from_database(value)
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{name}`"
+        end
+        alias_method :with_value_from_user, :with_value_from_database
       end
 
-      def value_for_database
-      end
+      class Uninitialized < Attribute # :nodoc:
+        UNINITIALIZED_ORIGINAL_VALUE = Object.new
 
-      def initialized?
-        false
+        def initialize(name, type)
+          super(name, nil, type)
+        end
+
+        def value
+          if block_given?
+            yield name
+          end
+        end
+
+        def original_value
+          UNINITIALIZED_ORIGINAL_VALUE
+        end
+
+        def value_for_database
+        end
+
+        def initialized?
+          false
+        end
+
+        def with_type(type)
+          self.class.new(name, type)
+        end
       end
-    end
-    private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
+      private_constant :FromDatabase, :FromUser, :Null, :Uninitialized, :WithCastValue
   end
 end