activerecord 5.0.0.1 → 5.0.1.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03a6d180e9ad1f0b0245bbf843f33de758ff41f8
-  data.tar.gz: 3680e9da9480357ba1a0f27b5b7c2a22fe43c3d4
+  metadata.gz: 953b40722753f09afe5e56d51a78a2aca83a26cf
+  data.tar.gz: 8331cc743634b2444a933cb84edbdc0dff79abfd
 SHA512:
-  metadata.gz: 7b2c9b69ef86ccb5b3152036494b3a6305fa13c4d8b89cecd64e4a1f7b34c8b76ed24356164fd4eb1c996d6b21aa51f84f1e0a0dae865133e04a4137481a43c1
-  data.tar.gz: c930e7945627ff78210190c18e04fb3fb615632ee00395e53e43e610e4888d5c3656b64d636bd86c6b21b11ae673a2e02e8973e292b5bfdce2e7692c773f32d7
+  metadata.gz: 3836e3ac44e8afe18c3fe46e957b9c0e59da3ff22ac3f1e2f5db91da867e40785b61db201266e5e86b7f2aaf27da250d9142547c4eb0802a2b76fd786d18053d
+  data.tar.gz: 96552fa27ac3c8516e5b88a16144730b812ea5e9948104befb4a3d4a417f73ec2e0f4690d724238a6113fa3224a47ecdcd73ffb0c699668c783fdafd95a99772

data/CHANGELOG.md

@@ -1,6 +1,200 @@
+## 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 +473,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 +1214,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.rb

@@ -68,7 +68,6 @@ module ActiveRecord
   autoload :StatementCache
   autoload :Store
   autoload :Suppressor
-  autoload :TableMetadata
   autoload :Timestamp
   autoload :Transactions
   autoload :Translation
@@ -101,6 +100,7 @@ module ActiveRecord
     end
 
     autoload :Result
+    autoload :TableMetadata
   end
 
   module Coders

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.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/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
+          scope.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