activerecord 4.0.5 → 4.0.6.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a0eee7da9c94ef26da56fe60b92893386de6d2b1
+  data.tar.gz: 9008c81b96ed86e1c650bbed89290d6c0e1b4802
+SHA512:
+  metadata.gz: c697cbcabccdf2e4494c67fc3c86f099686f8316a65d74a5986dbe6a022ec6eb3106b796d7e82722a43f86a4c91afca40e0f47b9e37a03dd4e6427bec0354d4c
+  data.tar.gz: 80fefaf272a8bf843e275c25abcdf528a6a6a2518fba10794f842a79bb2a8b675dd62546e736c90fc235ad71df3e00782330b8ca52d2752396010de2d1400cf5

data/CHANGELOG.md

@@ -1,3 +1,201 @@
+## Rails 4.0.6 (May 27, 2014) ##
+
+*   Fixed the inferred table name of a has_and_belongs_to_many auxiliar
+    table inside a schema.
+
+    Fixes #14824
+
+    *Eric Chahin*
+
+*   Fix bug that added `table_name_prefix` and `table_name_suffix` to
+    extension names in PostgreSQL when migrating.
+
+    *Joao Carlos*
+
+*   `ActiveRecord::Relation::Merger#filter_binds` now compares equivalent symbols and
+    strings in column names as equal.
+
+    This fixes a rare case in which more bind values are passed than there are
+    placeholders for them in the generated SQL statement, which can make PostgreSQL
+    throw a `StatementInvalid` exception.
+
+    *Nat Budin*
+
+*   Calling `delete_all` on an unloaded `CollectionProxy` no longer
+    generates a SQL statement containing each id of the collection:
+
+    Before:
+
+        DELETE FROM `model` WHERE `model`.`parent_id` = 1
+        AND `model`.`id` IN (1, 2, 3...)
+
+    After:
+
+        DELETE FROM `model` WHERE `model`.`parent_id` = 1
+
+    *Eileen M. Uchitelle*, *Aaron Patterson*
+
+*   Fix `stored_attributes` to correctly merge the details of stored
+    attributes defined in parent classes.
+
+    Fixes #14672.
+
+    *Brad Bennett*, *Jessica Yao*, *Lakshmi Parthasarathy*
+
+*   Fix bug where `ActiveRecord::Store` used a global `Hash` to keep track of
+    all registered `stored_attributes`. Now every subclass of
+    `ActiveRecord::Base` has it's own `Hash`.
+
+    *Yves Senn*
+
+*   `change_column_default` allows `[]` as argument to `change_column_default`.
+
+    Fixes #11586.
+
+    *Yves Senn*
+
+*   Fixed has_and_belongs_to_many's CollectionAssociation size calculation.
+
+    has_and_belongs_to_many should not include new records as part of
+    `#count_records` as new records are already counted.
+
+    Fixes #14914.
+
+    *Fred Wu*
+
+*   Stringify all variables keys of MySQL connection configuration.
+
+    When `sql_mode` variable for MySQL adapters set in configuration as `String`
+    was ignored and overwritten by strict mode option.
+
+    Fixes #14895.
+
+    *Paul Nikitochkin*
+
+*   Ensure SQLite3 statements are closed on errors.
+
+    Fixes: #13631.
+
+    *Timur Alperovich*
+
+*   When joining tables with a default scope, ensure the generated table name
+    in the `ON` conditions from the default scope is correctly aliased.
+
+    Backports #14154.
+
+    *Matt Jones*
+
+*   Fix name collision with `Array#select!` with `Relation#select!`.
+
+    Fixes #14752.
+
+    *Earl St Sauver*
+
+*   When a destroyed record is duped, the dup is not `destroyed?`.
+
+    *Kuldeep Aggarwal*
+
+*   Fixed has_many association to make it support irregular inflections.
+
+    Fixes #8928.
+
+    *arthurnn*, *Javier Goizueta*
+
+*   Fixed a problem where count used with a grouping was not returning a Hash.
+
+    Fixes #14721.
+
+    *Eric Chahin*
+
+*   Do not quote uuid default value on `change_column`.
+
+    Fixes #14604.
+
+    *Eric Chahin*
+
+*   The comparison between `Relation` and `CollectionProxy` should be consistent.
+
+    Example:
+
+        author.posts == Post.where(author_id: author.id)
+        # => true
+        Post.where(author_id: author.id) == author.posts
+        # => true
+
+    Fixes #13506.
+
+    *Lauro Caetano*
+
+*   PostgreSQL adapter only warns once for every missing OID per connection.
+
+    Fixes #14275.
+
+    *Matthew Draper*, *Yves Senn*
+
+*   Fix insertion of records via `has_many :through` association with scope.
+
+    Fixes #3548.
+
+    *Ivan Antropov*
+
+*   Make possible to have an association called `records`.
+
+    Fixes #11645.
+
+    *prathamesh-sonpatki*
+
+*   `to_sql` on an association now matches the query that is actually executed, where it
+    could previously have incorrectly accrued additional conditions (e.g. as a result of
+    a previous query). `CollectionProxy` now always defers to the association scope's
+    `arel` method so the (incorrect) inherited one should be entirely concealed.
+
+    Fixes #14003.
+
+    *Jefferson Lai*
+
+*   Fixed error when using `with_options` with lambda.
+
+    Fixes #9805.
+
+    *Lauro Caetano*
+
+*   Fixed error when specifying a non-empty default value on a PostgreSQL array column.
+
+    Fixes #10613.
+
+    *Luke Steensen*
+
+*   Make possible to change `record_timestamps` inside Callbacks.
+
+    *Tieg Zaharia*
+
+*   Fixed error where `#persisted?` throws `SystemStackError` for an unsaved model with a
+    custom primary key that didn't save due to validation error.
+
+    Fixes #14393.
+
+    *Chris Finne*
+
+*   `rake db:structure:dump` only dumps schema information if the schema
+    migration table exists.
+
+    Fixes #14217.
+
+    *Yves Senn*
+
+*   Fix counter cache when association uses a `class_name`.
+
+    Fixes #14369.
+
+    *arthurnn*
+
+*   Add support for `Relation` be passed as parameter on `QueryCache#select_all`.
+
+    Fixes #14361.
+
+    *arthurnn*
+
+
 ## Rails 4.0.5 (May 6, 2014) ##
 
 *No changes*

data/lib/active_record/association_relation.rb

@@ -9,6 +9,10 @@ module ActiveRecord
       @association
     end
 
+    def ==(other)
+      other == to_a
+    end
+
     private
 
     def exec_queries

data/lib/active_record/associations.rb

@@ -4,6 +4,12 @@ require 'active_support/core_ext/module/remove_method'
 require 'active_record/errors'
 
 module ActiveRecord
+  class AssociationNotFoundError < ConfigurationError #:nodoc:
+    def initialize(record, association_name)
+      super("Association named '#{association_name}' was not found on #{record.class.name}; perhaps you misspelled it?")
+    end
+  end
+
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
     def initialize(reflection, associated_class = nil)
       super("Could not find the inverse association for #{reflection.name} (#{reflection.options[:inverse_of].inspect} in #{associated_class.nil? ? reflection.class_name : associated_class.name})")
@@ -153,7 +159,7 @@ module ActiveRecord
       association = association_instance_get(name)
 
       if association.nil?
-        reflection  = self.class.reflect_on_association(name)
+        raise AssociationNotFoundError.new(self, name) unless reflection = self.class.reflect_on_association(name)
         association = reflection.association_class.new(self, reflection)
         association_instance_set(name, association)
       end

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

@@ -22,6 +22,7 @@ module ActiveRecord::Associations::Builder
     def add_counter_cache_callbacks(reflection)
       cache_column = reflection.counter_cache_column
       foreign_key = reflection.foreign_key
+      klass = reflection.class_name.safe_constantize
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def belongs_to_counter_cache_after_create_for_#{name}
@@ -43,8 +44,8 @@ module ActiveRecord::Associations::Builder
         def belongs_to_counter_cache_after_update_for_#{name}
           if (@_after_create_counter_called ||= false)
             @_after_create_counter_called = false
-          elsif self.#{foreign_key}_changed? && !new_record? && defined?(#{name.to_s.camelize})
-            model = #{name.to_s.camelize}
+          elsif self.#{foreign_key}_changed? && !new_record? && #{constructable?}
+            model = #{klass}
             foreign_key_was = self.#{foreign_key}_was
             foreign_key = self.#{foreign_key}
 
@@ -61,8 +62,6 @@ module ActiveRecord::Associations::Builder
       model.after_create   "belongs_to_counter_cache_after_create_for_#{name}"
       model.before_destroy "belongs_to_counter_cache_before_destroy_for_#{name}"
       model.after_update   "belongs_to_counter_cache_after_update_for_#{name}"
-
-      klass = reflection.class_name.safe_constantize
       klass.attr_readonly cache_column if klass && klass.respond_to?(:attr_readonly)
     end
 

data/lib/active_record/associations/collection_association.rb

@@ -118,11 +118,11 @@ module ActiveRecord
       end
 
       def create(attributes = {}, &block)
-        create_record(attributes, &block)
+        _create_record(attributes, &block)
       end
 
       def create!(attributes = {}, &block)
-        create_record(attributes, true, &block)
+        _create_record(attributes, true, &block)
       end
 
       # Add +records+ to this association. Returns +self+ so method calls may
@@ -226,7 +226,7 @@ module ActiveRecord
             ActiveRecord::Base.logger ? ActiveRecord::Base.logger.warn(message) : $stderr.puts(message)
           end
 
-          if loaded? || dependent == :destroy
+          if (loaded? || dependent == :destroy) && dependent != :delete_all
             delete_or_destroy(load_target, dependent)
           else
             delete_records(:all, dependent)
@@ -449,13 +449,13 @@ module ActiveRecord
           persisted + memory
         end
 
-        def create_record(attributes, raise = false, &block)
+        def _create_record(attributes, raise = false, &block)
           unless owner.persisted?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
           end
 
           if attributes.is_a?(Array)
-            attributes.collect { |attr| create_record(attr, raise, &block) }
+            attributes.collect { |attr| _create_record(attr, raise, &block) }
           else
             transaction do
               add_to_target(build_record(attributes)) do |record|

data/lib/active_record/associations/collection_proxy.rb

@@ -833,6 +833,10 @@ module ActiveRecord
         !!@association.include?(record)
       end
 
+      def arel
+        scope.arel
+      end
+
       def proxy_association
         @association
       end
@@ -849,8 +853,6 @@ module ActiveRecord
       def scope
         @association.scope
       end
-
-      # :nodoc:
       alias spawn scope
 
       # Equivalent to <tt>Array#==</tt>. Returns +true+ if the two arrays

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -35,7 +35,7 @@ module ActiveRecord
       private
 
         def count_records
-          load_target.size
+          load_target.reject { |r| r.new_record? }.size
         end
 
         def delete_records(records, method)

data/lib/active_record/associations/has_many_association.rb

@@ -73,15 +73,15 @@ module ActiveRecord
           [association_scope.limit_value, count].compact.min
         end
 
-        def has_cached_counter?(reflection = reflection)
+        def has_cached_counter?(reflection = reflection())
           owner.attribute_present?(cached_counter_attribute_name(reflection))
         end
 
-        def cached_counter_attribute_name(reflection = reflection)
+        def cached_counter_attribute_name(reflection = reflection())
           options[:counter_cache] || "#{reflection.name}_count"
         end
 
-        def update_counter(difference, reflection = reflection)
+        def update_counter(difference, reflection = reflection())
           if has_cached_counter?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner.class.update_counters(owner.id, counter => difference)
@@ -100,7 +100,7 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection)
+        def inverse_updates_counter_cache?(reflection = reflection())
           counter_name = cached_counter_attribute_name(reflection)
           reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
             inverse_reflection.counter_cache_column == counter_name

data/lib/active_record/associations/has_many_through_association.rb

@@ -84,12 +84,16 @@ module ActiveRecord
           @through_records[record.object_id] ||= begin
             ensure_mutable
 
-            through_record = through_association.build
+            through_record = through_association.build through_scope_attributes
             through_record.send("#{source_reflection.name}=", record)
             through_record
           end
         end
 
+        def through_scope_attributes
+          scope.where_values_hash(through_association.reflection.name.to_s)
+        end
+
         def save_through_record(record)
           build_through_record(record).save!
         ensure

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

@@ -106,7 +106,7 @@ module ActiveRecord
               ]
             end
 
-            scope_chain_items += [reflection.klass.send(:build_default_scope)].compact
+            scope_chain_items += [reflection.klass.send(:build_default_scope, ActiveRecord::Relation.new(reflection.klass, table))].compact
 
             scope_chain_items.each do |item|
               unless item.is_a?(Relation)

data/lib/active_record/associations/preloader.rb

@@ -132,34 +132,13 @@ module ActiveRecord
       end
 
       def grouped_records(association)
-        Hash[
-          records_by_reflection(association).map do |reflection, records|
-            [reflection, records.group_by { |record| association_klass(reflection, record) }]
-          end
-        ]
-      end
-
-      def records_by_reflection(association)
-        records.group_by do |record|
-          record_class = record.class
-          reflection = record_class.reflections[association]
-
-          unless reflection
-            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found on #{record_class.name}; " \
-                                                    "perhaps you misspelled it?"
-          end
-
-          reflection
-        end
-      end
-
-      def association_klass(reflection, record)
-        if reflection.macro == :belongs_to && reflection.options[:polymorphic]
-          klass = record.send(reflection.foreign_type)
-          klass && klass.constantize
-        else
-          reflection.klass
+        h = {}
+        records.each do |record|
+          assoc = record.association(association)
+          klasses = h[assoc.reflection] ||= {}
+          (klasses[assoc.klass] ||= []) << record
         end
+        h
       end
 
       def preloader_for(reflection)

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

@@ -106,7 +106,7 @@ module ActiveRecord
           scope.where_values      = Array(values[:where])      + Array(preload_values[:where])
           scope.references_values = Array(values[:references]) + Array(preload_values[:references])
 
-          scope.select!   preload_values[:select] || values[:select] || table[Arel.star]
+          scope._select!   preload_values[:select] || values[:select] || table[Arel.star]
           scope.includes! preload_values[:includes] || values[:includes]
 
           if options[:as]