activerecord 5.0.0.1 → 5.0.1.rc1

data/lib/active_record/associations/has_many_through_association.rb

@@ -203,6 +203,10 @@ module ActiveRecord
         def invertible_for?(record)
           false
         end
+
+        def append_record(record)
+          @target << record
+        end
     end
   end
 end

data/lib/active_record/associations/join_dependency.rb

@@ -272,7 +272,11 @@ module ActiveRecord
             construct(model, node, row, rs, seen, model_cache, aliases)
           else
             model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            model.readonly!
+
+            if node.reflection.scope_for(node.base_klass).readonly_value
+              model.readonly!
+            end
+
             seen[ar_parent.object_id][node.base_klass][id] = model
             construct(model, node, row, rs, seen, model_cache, aliases)
           end
@@ -280,17 +284,19 @@ module ActiveRecord
       end
 
       def construct_model(record, node, row, model_cache, id, aliases)
-        model = model_cache[node][id] ||= node.instantiate(row,
-                                                           aliases.column_aliases(node))
         other = record.association(node.reflection.name)
 
+        model = model_cache[node][id] ||=
+          node.instantiate(row, aliases.column_aliases(node)) do |m|
+            other.set_inverse_instance(m)
+          end
+
         if node.reflection.collection?
           other.target.push(model)
         else
           other.target = model
         end
 
-        other.set_inverse_instance(model)
         model
       end
     end

data/lib/active_record/associations/join_dependency/join_part.rb

@@ -62,8 +62,8 @@ module ActiveRecord
           hash
         end
 
-        def instantiate(row, aliases)
-          base_klass.instantiate(extract_record(row, aliases))
+        def instantiate(row, aliases, &block)
+          base_klass.instantiate(extract_record(row, aliases), &block)
         end
       end
     end

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

@@ -62,7 +62,12 @@ module ActiveRecord
         private
 
         def associated_records_by_owner(preloader)
-          records = load_records
+          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])] || []
           end
@@ -79,6 +84,15 @@ module ActiveRecord
           @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
+            end
+          end
+          @owners_by_key
+        end
+
         def key_conversion_required?
           @key_conversion_required ||= association_key_type != owner_key_type
         end
@@ -99,13 +113,13 @@ module ActiveRecord
           @model.type_for_attribute(owner_key_name.to_s).type
         end
 
-        def load_records
+        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)
+            records_for(slice).load(&block)
           end
           @preloaded_records.group_by do |record| 
             convert_key(record[association_key_name])
@@ -113,7 +127,7 @@ module ActiveRecord
         end
 
         def reflection_scope
-          @reflection_scope ||= reflection.scope ? klass.unscoped.instance_exec(nil, &reflection.scope) : klass.unscoped
+          @reflection_scope ||= reflection.scope_for(klass)
         end
 
         def build_scope

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

@@ -9,7 +9,6 @@ module ActiveRecord
             association = owner.association(reflection.name)
             association.loaded!
             association.target.concat(records)
-            records.each { |record| association.set_inverse_instance(record) }
           end
         end
       end

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

@@ -11,7 +11,6 @@ module ActiveRecord
 
             association = owner.association(reflection.name)
             association.target = record
-            association.set_inverse_instance(record) if record
           end
         end
 

data/lib/active_record/associations/singular_association.rb

@@ -6,8 +6,7 @@ module ActiveRecord
         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`
-            on the parent object instead.
+            deprecated and will be removed in Rails 5.1. Please call `reload_#{reflection.name}` instead.
           MSG
 
           klass.uncached { reload }
@@ -38,6 +37,13 @@ module ActiveRecord
         record
       end
 
+      # Implements the reload reader method, e.g. foo.reload_bar for
+      # Foo.has_one :bar
+      def force_reload_reader
+        klass.uncached { reload }
+        target
+      end
+
       private
 
         def create_scope

data/lib/active_record/attribute.rb

@@ -65,7 +65,7 @@ module ActiveRecord
 
     def with_value_from_user(value)
       type.assert_valid_value(value)
-      self.class.from_user(name, value, type, self)
+      self.class.from_user(name, value, type, original_attribute || self)
     end
 
     def with_value_from_database(value)
@@ -132,7 +132,7 @@ module ActiveRecord
     end
 
     def _original_value_for_database
-      value_for_database
+      type.serialize(original_value)
     end
 
     class FromDatabase < Attribute # :nodoc:
@@ -160,7 +160,7 @@ module ActiveRecord
         value
       end
 
-      def changed_in_place_from?(old_value)
+      def changed_in_place?
         false
       end
     end

data/lib/active_record/attribute_methods.rb

@@ -279,9 +279,8 @@ module ActiveRecord
     # Returns an <tt>#inspect</tt>-like string for the value of the
     # attribute +attr_name+. String attributes are truncated up to 50
     # characters, Date and Time attributes are returned in the
-    # <tt>:db</tt> format, Array attributes are truncated up to 10 values.
-    # Other attributes return the value of <tt>#inspect</tt> without
-    # modification.
+    # <tt>:db</tt> format. Other attributes return the value of
+    # <tt>#inspect</tt> without modification.
     #
     #   person = Person.create!(name: 'David Heinemeier Hansson ' * 3)
     #
@@ -292,7 +291,7 @@ module ActiveRecord
     #   # => "\"2012-10-22 00:15:07\""
     #
     #   person.attribute_for_inspect(:tag_ids)
-    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...]"
+    #   # => "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]"
     def attribute_for_inspect(attr_name)
       value = read_attribute(attr_name)
 
@@ -300,9 +299,6 @@ module ActiveRecord
         "#{value[0, 50]}...".inspect
       elsif value.is_a?(Date) || value.is_a?(Time)
         %("#{value.to_s(:db)}")
-      elsif value.is_a?(Array) && value.size > 10
-        inspected = value.first(10).inspect
-        %(#{inspected[0...-1]}, ...])
       else
         value.inspect
       end

data/lib/active_record/attribute_methods/primary_key.rb

@@ -95,7 +95,8 @@ module ActiveRecord
             base_name.foreign_key
           else
             if ActiveRecord::Base != self && table_exists?
-              connection.schema_cache.primary_keys(table_name)
+              pk = connection.schema_cache.primary_keys(table_name)
+              suppress_composite_primary_key(pk)
             else
               'id'
             end
@@ -122,6 +123,18 @@ module ActiveRecord
           @quoted_primary_key = nil
           @attributes_builder = nil
         end
+
+        private
+
+        def suppress_composite_primary_key(pk)
+          return pk unless pk.is_a?(Array)
+
+          warn <<-WARNING.strip_heredoc
+            WARNING: Active Record does not support composite primary key.
+
+            #{table_name} has composite primary key. Composite primary key is ignored.
+          WARNING
+        end
       end
     end
   end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -39,7 +39,7 @@ module ActiveRecord
         end
 
         def set_time_zone_without_conversion(value)
-          ::Time.zone.local_to_utc(value).in_time_zone
+          ::Time.zone.local_to_utc(value).in_time_zone if value
         end
 
         def map_avoiding_infinite_recursion(value)

data/lib/active_record/attribute_set.rb

@@ -2,6 +2,8 @@ require 'active_record/attribute_set/builder'
 
 module ActiveRecord
   class AttributeSet # :nodoc:
+    delegate :fetch, to: :attributes
+
     def initialize(attributes)
       @attributes = attributes
     end

data/lib/active_record/attribute_set/builder.rb

@@ -3,11 +3,12 @@ require 'active_record/attribute'
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      attr_reader :types, :always_initialized
+      attr_reader :types, :always_initialized, :default
 
-      def initialize(types, always_initialized = nil)
+      def initialize(types, always_initialized = nil, &default)
         @types = types
         @always_initialized = always_initialized
+        @default = default
       end
 
       def build_from_database(values = {}, additional_types = {})
@@ -15,21 +16,22 @@ module ActiveRecord
           values[always_initialized] = nil
         end
 
-        attributes = LazyAttributeHash.new(types, values, additional_types)
+        attributes = LazyAttributeHash.new(types, values, additional_types, &default)
         AttributeSet.new(attributes)
       end
     end
   end
 
   class LazyAttributeHash # :nodoc:
-    delegate :transform_values, :each_key, to: :materialize
+    delegate :transform_values, :each_key, :fetch, to: :materialize
 
-    def initialize(types, values, additional_types)
+    def initialize(types, values, additional_types, &default)
       @types = types
       @values = values
       @additional_types = additional_types
       @materialized = false
       @delegate_hash = {}
+      @default = default || proc {}
     end
 
     def key?(key)
@@ -76,9 +78,29 @@ module ActiveRecord
       end
     end
 
+    def marshal_dump
+      materialize
+    end
+
+    def marshal_load(delegate_hash)
+      @delegate_hash = delegate_hash
+      @types = {}
+      @values = {}
+      @additional_types = {}
+      @materialized = true
+    end
+
+    def encode_with(coder)
+      coder["delegate_hash"] = materialize
+    end
+
+    def init_with(coder)
+      marshal_load(coder["delegate_hash"])
+    end
+
     protected
 
-    attr_reader :types, :values, :additional_types, :delegate_hash
+    attr_reader :types, :values, :additional_types, :delegate_hash, :default
 
     def materialize
       unless @materialized
@@ -101,7 +123,7 @@ module ActiveRecord
       if value_present
         delegate_hash[name] = Attribute.from_database(name, value, type)
       elsif types.key?(name)
-        delegate_hash[name] = Attribute.uninitialized(name, type)
+        delegate_hash[name] = default.call(name) || Attribute.uninitialized(name, type)
       end
     end
   end

data/lib/active_record/attributes.rb

@@ -34,10 +34,10 @@ module ActiveRecord
       # is not passed, the previous default value (if any) will be used.
       # Otherwise, the default will be +nil+.
       #
-      # +array+ (PG only) specifies that the type should be an array (see the
+      # +array+ (PostgreSQL only) specifies that the type should be an array (see the
       # examples below).
       #
-      # +range+ (PG only) specifies that the type should be a range (see the
+      # +range+ (PostgreSQL only) specifies that the type should be a range (see the
       # examples below).
       #
       # ==== Examples
@@ -253,7 +253,7 @@ module ActiveRecord
             name,
             value,
             type,
-            _default_attributes[name],
+            _default_attributes.fetch(name.to_s) { nil },
           )
         else
           default_attribute = Attribute.from_database(name, value, type)

data/lib/active_record/autosave_association.rb

@@ -329,26 +329,20 @@ module ActiveRecord
         return true if record.destroyed? || (reflection.options[:autosave] && record.marked_for_destruction?)
 
         validation_context = self.validation_context unless [:create, :update].include?(self.validation_context)
+
         unless valid = record.valid?(validation_context)
           if reflection.options[:autosave]
             indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveRecord::Base.index_nested_attribute_errors)
 
             record.errors.each do |attribute, message|
-              if indexed_attribute
-                attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                attribute = "#{reflection.name}.#{attribute}"
-              end
+              attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
               errors[attribute] << message
               errors[attribute].uniq!
             end
 
             record.errors.details.each_key do |attribute|
-              if indexed_attribute
-                reflection_attribute = "#{reflection.name}[#{index}].#{attribute}"
-              else
-                reflection_attribute = "#{reflection.name}.#{attribute}"
-              end
+              reflection_attribute =
+                normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym
 
               record.errors.details[attribute].each do |error|
                 errors.details[reflection_attribute] << error
@@ -362,6 +356,14 @@ module ActiveRecord
         valid
       end
 
+      def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
+        if indexed_attribute
+          "#{reflection.name}[#{index}].#{attribute}"
+        else
+          "#{reflection.name}.#{attribute}"
+        end
+      end
+
       # Is used as a before_save callback to check while saving a collection
       # association whether or not the parent was a new record before saving.
       def before_save_collection_association
@@ -457,7 +459,9 @@ module ActiveRecord
       # In addition, it will destroy the association if it was marked for destruction.
       def save_belongs_to_association(reflection)
         association = association_instance_get(reflection.name)
-        record      = association && association.load_target
+        return unless association && association.loaded? && !association.stale_target?
+
+        record = association.load_target
         if record && !record.destroyed?
           autosave = reflection.options[:autosave]
 

data/lib/active_record/base.rb

@@ -312,8 +312,8 @@ module ActiveRecord #:nodoc:
     include NestedAttributes
     include Aggregations
     include Transactions
-    include NoTouching
     include TouchLater
+    include NoTouching
     include Reflection
     include Serialization
     include Store

data/lib/active_record/connection_adapters/abstract/connection_pool.rb

@@ -307,6 +307,7 @@ module ActiveRecord
       end
 
       include MonitorMixin
+      include QueryCache::ConnectionPoolConfiguration
 
       attr_accessor :automatic_reconnect, :checkout_timeout, :schema_cache
       attr_reader :spec, :connections, :size, :reaper
@@ -349,8 +350,7 @@ module ActiveRecord
         # currently in the process of independently establishing connections to the DB.
         @now_connecting = 0
 
-        # A boolean toggle that allows/disallows new connections.
-        @new_cons_enabled = true
+        @threads_blocking_new_connections = 0
 
         @available = ConnectionLeasingQueue.new self
       end
@@ -415,7 +415,10 @@ module ActiveRecord
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect!
             end
             @connections = []
@@ -442,33 +445,19 @@ module ActiveRecord
       #   connections in the pool within a timeout interval (default duration is
       #   <tt>spec.config[:checkout_timeout] * 2</tt> seconds).
       def clear_reloadable_connections(raise_on_acquisition_timeout = true)
-        num_new_conns_required = 0
-
         with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
           synchronize do
             @connections.each do |conn|
-              checkin conn
+              if conn.in_use?
+                conn.steal!
+                checkin conn
+              end
               conn.disconnect! if conn.requires_reloading?
             end
             @connections.delete_if(&:requires_reloading?)
-
             @available.clear
-
-            if @connections.size < @size
-              # because of the pruning done by this method, we might be running
-              # low on connections, while threads stuck in queue are helpless
-              # (not being able to establish new connections for themselves),
-              # see also more detailed explanation in +remove+
-              num_new_conns_required = num_waiting_in_queue - @connections.size
-            end
-
-            @connections.each do |conn|
-              @available.add conn
-            end
           end
         end
-
-        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Clears the cache which maps classes and re-connects connections that
@@ -556,17 +545,17 @@ module ActiveRecord
         stale_connections = synchronize do
           @connections.select do |conn|
             conn.in_use? && !conn.owner.alive?
+          end.each do |conn|
+            conn.steal!
           end
         end
 
         stale_connections.each do |conn|
-          synchronize do
-            if conn.active?
-              conn.reset!
-              checkin conn
-            else
-              remove conn
-            end
+          if conn.active?
+            conn.reset!
+            checkin conn
+          else
+            remove conn
           end
         end
       end
@@ -675,13 +664,32 @@ module ActiveRecord
       end
 
       def with_new_connections_blocked
-        previous_value = nil
         synchronize do
-          previous_value, @new_cons_enabled = @new_cons_enabled, false
+          @threads_blocking_new_connections += 1
         end
+
         yield
       ensure
-        synchronize { @new_cons_enabled = previous_value }
+        num_new_conns_required = 0
+
+        synchronize do
+          @threads_blocking_new_connections -= 1
+
+          if @threads_blocking_new_connections.zero?
+            @available.clear
+
+            num_new_conns_required = num_waiting_in_queue
+
+            @connections.each do |conn|
+              next if conn.in_use?
+
+              @available.add conn
+              num_new_conns_required -= 1
+            end
+          end
+        end
+
+        bulk_make_new_connections(num_new_conns_required) if num_new_conns_required > 0
       end
 
       # Acquire a connection by one of 1) immediately removing one
@@ -733,7 +741,7 @@ module ActiveRecord
         # and increment @now_connecting, to prevent overstepping this pool's @size
         # constraint
         do_checkout = synchronize do
-          if @new_cons_enabled && (@connections.size + @now_connecting) < @size
+          if @threads_blocking_new_connections.zero? && (@connections.size + @now_connecting) < @size
             @now_connecting += 1
           end
         end