activerecord 5.0.0 → 5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 175e4ed30958c211689abda4a5664d2314821c19
-  data.tar.gz: b22c909734c877decd541b4585e6107f4a853824
+  metadata.gz: 234898d7d61339658ef46af85f6fdb265b658680
+  data.tar.gz: 642894eb2481573526cb1354bd138c000f422713
 SHA512:
-  metadata.gz: eb75298c265d53bb950437f9eeabe32ce75a5226aa1eb180d014cb3420ee7895a97ac74f2a2d7643b54f6fce7106a2c33d169fe288c6e9950f3d726dd7488b17
-  data.tar.gz: 7999af5a3505e7e95ea5b1226d0ff2bf5af784e59b3355376dbb0d4fe79a1a79346ebcfbb9d2a524797e376843a2213b2fc60a69d61aa519d60ba86f9cde37c9
+  metadata.gz: 803f30b6ebb0c25c3f1f478a9c412591d8b1c3daef6e888fbbe17257289392b9950f5ef19825d1ee133c826536a3d63fd23d04dd6f49091eec2af7017c029d86
+  data.tar.gz: 2caf2093ce411ac3cc8fa467b2d0fa2fca8ca46fa63e0aab0f903c10a9a0099e55cfe98abbdd07a08d4270a7ee9618a5cb2f1450abcbe760a18999ff874e2152

data/CHANGELOG.md

@@ -1,6 +1,222 @@
+## Rails 5.0.1 (December 21, 2016) ##
+
+*   No changes.
+
+
+## Rails 5.0.1.rc2 (December 10, 2016) ##
+
+*   Correct resolution of associated class in `has_many :through`
+    associations' `*_ids` setters.
+
+    Fixes #27297.
+
+    *Matthew Draper*
+
+*   Support index length and order options using both string and symbol
+    column names.
+
+    Fixes #27243.
+
+    *Ryuta Kamizono*
+
+
+## Rails 5.0.1.rc1 (December 01, 2016) ##
+
+*   Fix that unsigned with zerofill is treated as signed.
+
+    Fixes #27125.
+
+    *Ryuta Kamizono*
+
+*   Fix the uniqueness validation scope with a polymorphic association.
+
+    *Sergey Alekseev*
+
+*   Raise ActiveRecord::RecordNotFound from collection `*_ids` setters
+    for unknown IDs with a better error message.
+
+    Changes the collection `*_ids` setters to cast provided IDs the data
+    type of the primary key set in the association, not the model
+    primary key.
+
+    *Dominic Cleal*
+
+*   Introduce `Model#reload_<association>` to bring back the behavior
+    of `Article.category(true)` where `category` is a singular
+    association.
+
+    The force reloading of the association reader was deprecated
+    in #20888. Unfortunately the suggested alternative of
+    `article.reload.category` does not expose the same behavior.
+
+    This patch adds a reader method with the prefix `reload_` for
+    singular associations. This method has the same semantics as
+    passing true to the association reader used to have.
+
+    *Yves Senn*
+
+*   Make sure eager loading `ActiveRecord::Associations` also loads
+    constants defined in `ActiveRecord::Associations::Preloader`.
+
+    *Yves Senn*
+
+*   Allow `ActionController::Parameters`-like objects to be passed as
+    values for Postgres HStore columns.
+
+    Fixes #26904.
+
+    *Jon Moss*
+
+*   Configure query caching (per thread) on the connection pool.
+
+    Moving the configuration to the pool means we don't allocate a connection
+    until it's actually needed.
+
+    Applications that manually interact with the connection pool and/or query
+    cache may notice that the connection's cache is now cleared and disabled
+    when it gets returned to the pool, even if the request is not yet completed.
+
+    *Samuel Cochran*, *Matthew Draper*
+
+*   Fixed support for case insensitive comparisons of `text` columns in
+    PostgreSQL.
+
+    *Edho Arief*
+
+*   Return `true` from `update_attribute` when the value of the attribute
+    to be updated is unchanged.
+
+    Fixes #26593.
+
+    *Prathamesh Sonpatki*
+
+*   Serialize JSON attribute value `nil` as SQL `NULL`, not JSON `null`
+
+    *Trung Duc Tran*
+
+*   Always store errors details information with symbols.
+
+    When the association is autosaved we were storing the details with
+    string keys. This was creating inconsistency with other details that are
+    added using the `Errors#add` method. It was also inconsistent with the
+    `Errors#messages` storage.
+
+    To fix this inconsistency we are always storing with symbols. This will
+    cause a small breaking change because in those cases the details could
+    be accessed as strings keys but now it can not.
+
+    Fix #26499.
+
+    *Rafael Mendonça França*, *Marcus Vieira*
+
+*   Using a mysql2 connection after it fails to reconnect will now have an error message
+    saying the connection is closed rather than an undefined method error message.
+
+    *Dylan Thacker-Smith*
+
+*   Remove unnecessarily association load when a `belongs_to` association has already been
+    loaded then the foreign key is changed directly and the record saved.
+
+    *James Coleman*
+
+*   PostgreSQL array columns will now respect the encoding of strings contained
+    in the array.
+
+    Fixes #26326.
+
+    *Sean Griffin*
+
+*   Inverse association instances will now be set before `after_find` or
+    `after_initialize` callbacks are run.
+
+    Fixes #26320.
+
+    *Sean Griffin*
+
+*   Avoid loading records from database when they are already loaded using
+    the `pluck` method on a collection.
+
+    Fixes #25921.
+
+    *Ryuta Kamizono*
+
+*   Sqlite3 migrations to add a column to an existing table can now be
+    successfully rolled back when the column was given and invalid column
+    type.
+
+    Fixes #26087
+
+    *Travis O'Neill*
+
+*   Hashes can once again be passed to setters of `composed_of`, if all of the
+    mapping methods are methods implemented on `Hash`.
+
+    Fixes #25978.
+
+    *Sean Griffin*
+
+*   Doing count on relations that contain LEFT OUTER JOIN Arel node no longer
+    force a DISTINCT. This solves issues when using count after a left_joins.
+
+    *Maxime Handfield Lapointe*
+
+*   RecordNotFound raised by association.find exposes `id`, `primary_key` and
+    `model` methods to be consistent with RecordNotFound raised by Record.find.
+
+    *Michel Pigassou*
+
+*   Fix the SELECT statement in `#table_comment` for MySQL.
+
+    *Takeshi Akima*
+
+*   Virtual attributes will no longer raise when read on models loaded from the
+    database
+
+    *Sean Griffin*
+
+*   Fixes multi-parameter attributes conversion with invalid params.
+
+    *Hiroyuki Ishii*
+
+*   Add newline between each migration in `structure.sql`.
+
+    Keeps schema migration inserts as a single commit, but allows for easier
+    git diff-ing. Fixes #25504.
+
+    *Grey Baker*, *Norberto Lopes*
+
+*   Using `group` with an attribute that has a custom type will properly cast
+    the hash keys after calling a calculation method like `count`.
+
+    Fixes #25595.
+
+    *Sean Griffin*
+
+*   Ensure concurrent invocations of the connection reaper cannot allocate the
+    same connection to two threads.
+
+    Fixes #25585.
+
+    *Matthew Draper*
+
+*   Fixed dumping of foreign key's referential actions when MySQL connection
+    uses `sql_mode = ANSI_QUOTES`.
+
+    Fixes #25300.
+
+    *Ryuta Kamizono*
+
+
 ## Rails 5.0.0 (June 30, 2016) ##
 
+*   Inspecting an object with an associated array of over 10 elements no longer
+    truncates the array, preventing `inspect` from looping infinitely in some
+    cases.
+
+    *Kevin McPhillips*
+
 *   Ensure hashes can be assigned to attributes created using `composed_of`.
+
     Fixes #25210.
 
     *Sean Griffin*
@@ -279,7 +495,7 @@
 
     *Takashi Kokubun*
 
-*   Add ActiveRecord `#second_to_last` and `#third_to_last` methods.
+*   Add `#second_to_last` and `#third_to_last` finder methods.
 
     *Brian Christian*
 
@@ -1020,7 +1236,7 @@
 
     *Mehmet Emin İNAÇ*
 
-*   Add `cache_key` to ActiveRecord::Relation.
+*   Add `cache_key` to `ActiveRecord::Relation`.
 
     Example:
 

data/README.rdoc

@@ -192,7 +192,7 @@ The latest version of Active Record can be installed with RubyGems:
 
 Source code can be downloaded as part of the Rails project on GitHub:
 
-* https://github.com/rails/rails/tree/master/activerecord
+* https://github.com/rails/rails/tree/5-0-stable/activerecord
 
 
 == License

data/lib/active_record/aggregations.rb

@@ -261,8 +261,10 @@ module ActiveRecord
               part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
             end
 
-            if part.is_a?(Hash)
-              raise ArgumentError unless part.size == part.keys.max
+            hash_from_multiparameter_assignment = part.is_a?(Hash) &&
+              part.each_key.all? { |k| k.is_a?(Integer) }
+            if hash_from_multiparameter_assignment
+              raise ArgumentError unless part.size == part.each_key.max
               part = klass.new(*part.sort.map(&:last))
             end
 

data/lib/active_record/association_relation.rb

@@ -29,7 +29,10 @@ module ActiveRecord
     private
 
     def exec_queries
-      super.each { |r| @association.set_inverse_instance r }
+      super do |r|
+        @association.set_inverse_instance r
+        yield r if block_given?
+      end
     end
   end
 end

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

@@ -76,8 +76,10 @@ module ActiveRecord::Associations::Builder # :nodoc:
           left_model.retrieve_connection
         end
 
-        def self.primary_key
-          false
+        private
+
+        def self.suppress_composite_primary_key(pk)
+          pk unless pk.is_a?(Array)
         end
       }
 

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

@@ -8,7 +8,16 @@ module ActiveRecord::Associations::Builder # :nodoc:
 
     def self.define_accessors(model, reflection)
       super
-      define_constructors(model.generated_association_methods, reflection.name) if reflection.constructable?
+      mixin = model.generated_association_methods
+      name = reflection.name
+
+      define_constructors(mixin, name) if reflection.constructable?
+
+      mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
+        def reload_#{name}
+          association(:#{name}).force_reload_reader
+        end
+      CODE
     end
 
     # Defines the (build|create)_association methods for belongs_to or has_one association

data/lib/active_record/associations/collection_association.rb

@@ -69,13 +69,17 @@ module ActiveRecord
 
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
-        pk_type = reflection.primary_key_type
+        pk_type = reflection.association_primary_key_type
         ids = Array(ids).reject(&:blank?)
         ids.map! { |i| pk_type.cast(i) }
         records = klass.where(reflection.association_primary_key => ids).index_by do |r|
           r.send(reflection.association_primary_key)
-        end.values_at(*ids)
-        replace(records)
+        end.values_at(*ids).compact
+        if records.size != ids.size
+          klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, reflection.association_primary_key)
+        else
+          replace(records)
+        end
       end
 
       def reset
@@ -312,9 +316,9 @@ module ActiveRecord
           else
             target.size
           end
-        elsif !loaded? && !association_scope.group_values.empty?
+        elsif !association_scope.group_values.empty?
           load_target.size
-        elsif !loaded? && !association_scope.distinct_value && target.is_a?(Array)
+        elsif !association_scope.distinct_value && target.is_a?(Array)
           unsaved_records = target.select(&:new_record?)
           unsaved_records.size + count_records
         else
@@ -426,15 +430,12 @@ module ActiveRecord
       def replace_on_target(record, index, skip_callbacks)
         callback(:before_add, record) unless skip_callbacks
 
-        was_loaded = loaded?
         yield(record) if block_given?
 
-        unless !was_loaded && loaded?
-          if index
-            @target[index] = record
-          else
-            @target << record
-          end
+        if index
+          @target[index] = record
+        else
+          append_record(record)
         end
 
         callback(:after_add, record) unless skip_callbacks
@@ -454,7 +455,7 @@ module ActiveRecord
       end
 
       private
-      def get_records
+      def get_records(&block)
         return scope.to_a if skip_statement_cache?
 
         conn = klass.connection
@@ -466,13 +467,13 @@ module ActiveRecord
         end
 
         binds = AssociationScope.get_bind_values(owner, reflection.chain)
-        sc.execute binds, klass, klass.connection
+        sc.execute(binds, klass, klass.connection, &block)
       end
 
         def find_target
-          records = get_records
-          records.each { |record| set_inverse_instance(record) }
-          records
+          get_records do |record|
+            set_inverse_instance(record)
+          end
         end
 
         # We have some records loaded from the database (persisted) and some that are
@@ -657,6 +658,10 @@ module ActiveRecord
             set_inverse_instance record if record.is_a? ActiveRecord::Base
           end
         end
+
+        def append_record(record)
+          @target << record unless @target.include?(record)
+        end
     end
   end
 end

data/lib/active_record/associations/collection_proxy.rb

@@ -28,8 +28,7 @@ module ActiveRecord
     # is computed directly through SQL and does not trigger by itself the
     # instantiation of the actual post records.
     class CollectionProxy < Relation
-      delegate(*(ActiveRecord::Calculations.public_instance_methods - [:count]), to: :scope)
-      delegate :find_nth, to: :scope
+      delegate :exists?, :update_all, :arel, to: :scope
 
       def initialize(klass, association) #:nodoc:
         @association = association
@@ -732,6 +731,14 @@ module ActiveRecord
         @association.count(column_name)
       end
 
+      def calculate(operation, column_name)
+        null_scope? ? scope.calculate(operation, column_name) : super
+      end
+
+      def pluck(*column_names)
+        null_scope? ? scope.pluck(*column_names) : super
+      end
+
       # Returns the size of the collection. If the collection hasn't been loaded,
       # it executes a <tt>SELECT COUNT(*)</tt> query. Else it calls <tt>collection.size</tt>.
       #
@@ -787,7 +794,7 @@ module ActiveRecord
       # Returns +true+ if the collection is empty. If the collection has been
       # loaded it is equivalent
       # to <tt>collection.size.zero?</tt>. If the collection has not been loaded,
-      # it is equivalent to <tt>collection.exists?</tt>. If the collection has
+      # it is equivalent to <tt>!collection.exists?</tt>. If the collection has
       # not already been loaded and you are going to fetch the records anyway it
       # is better to check <tt>collection.length.zero?</tt>.
       #
@@ -891,10 +898,6 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
-      def arel #:nodoc:
-        scope.arel
-      end
-
       def proxy_association
         @association
       end
@@ -1068,6 +1071,16 @@ module ActiveRecord
         proxy_association.reset_scope
         self
       end
+
+      private
+
+        def null_scope?
+          @association.null_scope?
+        end
+
+        def exec_queries
+          load_target
+        end
     end
   end
 end

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/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/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/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/associations.rb

@@ -224,6 +224,11 @@ module ActiveRecord
       autoload :AliasTracker
     end
 
+    def self.eager_load!
+      super
+      Preloader.eager_load!
+    end
+
     # Returns the association instance for the given name, instantiating it if it doesn't already exist
     def association(name) #:nodoc:
       association = association_instance_get(name)

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