activerecord 4.2.1 → 4.2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e94e5a7efd7f7b5d6f6c4f54ab7f550aceb8a74
-  data.tar.gz: 0642a120174b46d9b9df4fb80b054d8b1910ec0e
+  metadata.gz: b27166a8cdbbc938588145984ecc536905ea7b49
+  data.tar.gz: b835c5264868bb6df623a97c7d8cdab457fe35c8
 SHA512:
-  metadata.gz: 87d989e4855aaf884a0cb976e27ee3b2f31087042da42335606a6b8cfb29fb50091cd761335caf4b56520a4c54ed9ab349939cedbbec057912f164f355ea6f39
-  data.tar.gz: 51233b959dbacb3e288c7aaa22bc60a7e649c7de1d92fad811e42122eb9686375eddec10867266dcfdf520ab3a3a89edc93c76a1164d322e7445e93a9bab6383
+  metadata.gz: aa5ca2a1f3553ed395014a4c8808838dca260cec90266dc5dda61f4c8c4f5d4bc659ead3c4af9189555a96e87d4b053dcc04c8e5aae09744e4a4a0c14c57bb20
+  data.tar.gz: d9733d5c9e015373b0101299215f411cdc5dff68a961c307fe0336a5daa83bfa7992abe6266a43cb35690853f9df84921ee215ae54cfaf3baa2032aacc081418

data/CHANGELOG.md

@@ -1,4 +1,371 @@
-## Rails 4.2.1 (March 19, 2014) ##
+## Rails 4.2.7 (July 12, 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*
+
+*   Queries such as `Computer.joins(:monitor).group(:status).count` will now be
+    interpreted as  `Computer.joins(:monitor).group('computers.status').count`
+    so that when `Computer` and `Monitor` have both `status` columns we don't
+    have conflicts in projection.
+
+    *Rafael Sales*
+
+*   ActiveRecord::Relation#count: raise an ArgumentError when finder options
+    are specified or an ActiveRecord::StatementInvalid when an invalid type
+    is provided for a column name (e.g. a Hash).
+
+    Fixes #20434
+
+    *Konstantinos Rousis*
+
+*   Correctly pass MySQL options when using structure_dump or structure_load
+
+    Specifically, it fixes an issue when using SSL authentication.
+
+    *Alex Coomans*
+
+
+## Rails 4.2.6 (March 07, 2016) ##
+
+*   Fix a bug where using `t.foreign_key` twice with the same `to_table` within
+    the same table definition would only create one foreign key.
+
+    *George Millo*
+
+*   Fix regression in dirty attribute tracking after #dup.  Changes to the
+    clone no longer show as changed attributes in the original object.
+
+    *Dominic Cleal*
+
+*   Fix regression when loading fixture files with symbol keys.
+
+    Closes #22584.
+
+    *Yves Senn*
+
+*   Fix `rake db:structure:dump` on Postgres when multiple schemas are used.
+
+    Fixes #22346.
+
+    *Nick Muerdter*, *ckoenig*
+
+*   Introduce `connection.data_sources` and `connection.data_source_exists?`.
+    These methods determine what relations can be used to back Active Record
+    models (usually tables and views).
+
+    *Yves Senn*, *Matthew Draper*
+
+
+## Rails 4.2.5.2 (February 26, 2016) ##
+
+*   No changes.
+
+
+## Rails 4.2.5.1 (January 25, 2015) ##
+
+*   No changes.
+
+
+## Rails 4.2.5 (November 12, 2015) ##
+
+*   No longer pass deprecated option `-i` to `pg_dump`.
+
+    *Paul Sadauskas*
+
+*   Set `scope.reordering_value` to `true` if :reordering values are specified.
+
+    Fixes #21886.
+
+    *Hiroaki Izu*
+
+*   Avoid disabling errors on the PostgreSQL connection when enabling the
+    standard_conforming_strings setting. Errors were previously disabled because
+    the setting wasn't writable in Postgres 8.1 and didn't exist in earlier
+    versions. Now Rails only supports Postgres 8.2+ we're fine to assume the
+    setting exists. Disabling errors caused problems when using a connection
+    pooling tool like PgBouncer because it's not guaranteed to have the same
+    connection between calls to `execute` and it could leave the connection
+    with errors disabled.
+
+    Fixes #22101.
+
+    *Harry Marr*
+
+*   Includes HABTM returns correct size now. It's caused by the join dependency
+    only instantiates one HABTM object because the join table hasn't a primary key.
+
+    Fixes #16032.
+
+    Examples:
+
+        before:
+
+        Project.first.salaried_developers.size # => 3
+        Project.includes(:salaried_developers).first.salaried_developers.size # => 1
+
+        after:
+
+        Project.first.salaried_developers.size # => 3
+        Project.includes(:salaried_developers).first.salaried_developers.size # => 3
+
+    *Bigxiang*
+
+*   Descriptive error message when fixtures contain a missing column.
+
+    Closes #21201.
+
+    *Yves Senn*
+
+*   `bin/rake db:migrate` uses
+    `ActiveRecord::Tasks::DatabaseTasks.migrations_paths` instead of
+    `Migrator.migrations_paths`.
+
+    *Tobias Bielohlawek*
+
+*   Fix `rewhere` in a `has_many` association.
+
+    Fixes #21955.
+
+    *Josh Branchaud*, *Kal*
+
+*   Added run_cmd class method to ActiveRecord::Tasks::DatabaseTasks for
+    drying up Kernel.system() calls within this namespace and to avoid
+    shell expansion by using a paramter list instead of string as arguments
+    for Kernel.system(). Thanks to Nate Berkopec for supply patch to get
+    test units passing.
+
+    *Bryan Paxton*
+
+*   Avoid leaking the first relation we call `first` on, per model.
+
+    Fixes #21921.
+
+    *Matthew Draper*, *Jean Boussier*
+
+*   Allow deserialization of Active Record models that were YAML encoded prior
+    to Rails 4.2
+
+    *Sean Griffin*
+
+*   Correctly apply `unscope` when preloading through associations.
+
+    *Jimmy Bourassa*
+
+*   Ensure `select` quotes aliased attributes, even when using `from`.
+
+    Fixes #21488
+
+    *Sean Griffin & @johanlunds*
+
+*   Correct query for PostgreSQL 8.2 compatibility.
+
+    *Ben Murphy*, *Matthew Draper*
+
+*   Uniqueness validator raises descriptive error when running on a persisted
+    record without primary key.
+
+    Closes #21304.
+
+    *Yves Senn*
+
+
+## Rails 4.2.4 (August 24, 2015) ##
+
+*   Skip statement cache on through association reader.
+
+    If the through class has default scopes we should skip the statement
+    cache.
+
+    Closes #20745.
+
+    *Rafael Mendonça França*
+
+*   Fixes #19420. When generating schema.rb using Postgres BigInt[] data type
+    the limit: 8 was not coming through. This caused it to become Int[] data type
+    after doing a rebuild off of schema.rb.
+
+    *Jake Waller*
+
+*   Fix state being carried over from previous transaction.
+
+    Considering the following example where `name` is a required attribute.
+    Before we had `new_record?` returning `true` for a persisted record:
+
+        author = Author.create! name: 'foo'
+        author.name = nil
+        author.save        # => false
+        author.new_record? # => true
+
+    Fixes #20824.
+
+    *Roque Pinel*
+
+*   Correctly ignore `mark_for_destruction` when `autosave` isn't set to `true`
+    when validating associations.
+
+    Fixes #20882.
+
+    *Sean Griffin*
+
+*   Fix through associations using scopes having the scope merged multiple
+    times.
+
+    Fixes #20721.
+    Fixes #20727.
+
+    *Sean Griffin*
+
+*   `ActiveRecord::Base.dump_schema_after_migration` applies migration tasks
+    other than `db:migrate`. (eg. `db:rollback`, `db:migrate:dup`, ...)
+
+    Fixes #20743.
+
+    *Yves Senn*
+
+*   Correctly raise `ActiveRecord::AssociationTypeMismatch` when assigning
+    a wrong type to a namespaced association.
+
+    Fixes #20545.
+
+    *Diego Carrion*
+
+*   Prevent error when using `force_reload: true` on an unassigned polymorphic
+    belongs_to association.
+
+    Fixes #20426.
+
+    *James Dabbs*
+
+
+## Rails 4.2.3 (June 25, 2015) ##
+
+*   Let `WITH` queries (Common Table Expressions) be explainable.
+
+    *Vladimir Kochnev*
+
+*   Fix n+1 query problem when eager loading nil associations (fixes #18312)
+
+    *Sammy Larbi*
+
+*   Fixed an error which would occur in dirty checking when calling
+    `update_attributes` from a getter.
+
+    Fixes #20531.
+
+    *Sean Griffin*
+
+*   Ensure symbols passed to `ActiveRecord::Relation#select` are always treated
+    as columns.
+
+    Fixes #20360.
+
+    *Sean Griffin*
+
+*   Clear query cache when `ActiveRecord::Base#reload` is called.
+
+    *Shane Hender*
+
+*   Pass `:extend` option for `has_and_belongs_to_many` associations to the
+    underlying `has_many :through`.
+
+    *Jaehyun Shin*
+
+*   Make `unscope` aware of "less than" and "greater than" conditions.
+
+    *TAKAHASHI Kazuaki*
+
+*   Revert behavior of `db:schema:load` back to loading the full
+    environment. This ensures that initializers are run.
+
+    Fixes #19545.
+
+    *Yves Senn*
+
+*   Fix missing index when using `timestamps` with the `index` option.
+
+    The `index` option used with `timestamps` should be passed to both
+    `column` definitions for `created_at` and `updated_at` rather than just
+    the first.
+
+    *Paul Mucur*
+
+*   Rename `:class` to `:anonymous_class` in association options.
+
+    Fixes #19659.
+
+    *Andrew White*
+
+*   Fixed a bug where uniqueness validations would error on out of range values,
+    even if an validation should have prevented it from hitting the database.
+
+    *Andrey Voronkov*
+
+*   Foreign key related methods in the migration DSL respect
+    `ActiveRecord::Base.pluralize_table_names = false`.
+
+    Fixes #19643.
+
+    *Mehmet Emin İNAÇ*
+
+*   Reduce memory usage from loading types on pg.
+
+    Fixes #19578.
+
+    *Sean Griffin*
+
+*   Fix referencing wrong table aliases while joining tables of has many through
+    association (only when calling calculation methods).
+
+    Fixes #19276.
+
+    *pinglamb*
+
+*   Don't attempt to update counter caches, when the column wasn't selected.
+
+    Fixes #19437.
+
+    *Sean Griffin*
+
+*   Correctly persist a serialized attribute that has been returned to
+    its default value by an in-place modification.
+
+    Fixes #19467.
+
+    *Matthew Draper*
+
+*   Fix default `format` value in `ActiveRecord::Tasks::DatabaseTasks#schema_file`.
+
+    *James Cox*
+
+*   Dont enroll records in the transaction if they dont have commit callbacks.
+    That was causing a memory grow problem when creating a lot of records inside a transaction.
+
+    Fixes #15549.
+
+    *Will Bryant*, *Aaron Patterson*
+
+*   Correctly create through records when created on a has many through
+    association when using `where`.
+
+    Fixes #19073.
+
+    *Sean Griffin*
+
+
+## Rails 4.2.2 (June 16, 2015) ##
+
+* No Changes *
+
+
+## Rails 4.2.1 (March 19, 2015) ##
 
 *   Fixed ActiveRecord::Relation#becomes! and changed_attributes issues for type column
 

data/lib/active_record/aggregations.rb

@@ -244,14 +244,15 @@ module ActiveRecord
         def writer_method(name, class_name, mapping, allow_nil, converter)
           define_method("#{name}=") do |part|
             klass = class_name.constantize
-            if part.is_a?(Hash)
-              part = klass.new(*part.values)
-            end
 
             unless part.is_a?(klass) || converter.nil? || part.nil?
               part = converter.respond_to?(:call) ? converter.call(part) : klass.send(converter, part)
             end
 
+            if part.is_a?(Hash)
+              part = klass.new(*part.values)
+            end
+
             if part.nil? && allow_nil
               mapping.each { |key, _| self[key] = nil }
               @aggregation_cache[name] = nil

data/lib/active_record/association_relation.rb

@@ -13,6 +13,19 @@ module ActiveRecord
       other == to_a
     end
 
+    def build(*args, &block)
+      scoping { @association.build(*args, &block) }
+    end
+    alias new build
+
+    def create(*args, &block)
+      scoping { @association.create(*args, &block) }
+    end
+
+    def create!(*args, &block)
+      scoping { @association.create!(*args, &block) }
+    end
+
     private
 
     def exec_queries

data/lib/active_record/associations/association.rb

@@ -211,9 +211,12 @@ module ActiveRecord
         # the kind of the class of the associated objects. Meant to be used as
         # a sanity check when you are about to assign an associated record.
         def raise_on_type_mismatch!(record)
-          unless record.is_a?(reflection.klass) || record.is_a?(reflection.class_name.constantize)
-            message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
-            raise ActiveRecord::AssociationTypeMismatch, message
+          unless record.is_a?(reflection.klass)
+            fresh_class = reflection.class_name.safe_constantize
+            unless fresh_class && record.is_a?(fresh_class)
+              message = "#{reflection.class_name}(##{reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+              raise ActiveRecord::AssociationTypeMismatch, message
+            end
           end
         end
 
@@ -248,6 +251,15 @@ module ActiveRecord
             initialize_attributes(record)
           end
         end
+
+        # Returns true if statement cache should be skipped on the association reader.
+        def skip_statement_cache?
+          reflection.scope_chain.any?(&:any?) ||
+            scope.eager_loading? ||
+            klass.current_scope ||
+            klass.default_scopes.any? ||
+            reflection.source_reflection.active_record.default_scopes.any?
+        end
     end
   end
 end

data/lib/active_record/associations/association_scope.rb

@@ -162,6 +162,7 @@ module ActiveRecord
               scope.includes! item.includes_values
             end
 
+            scope.unscope!(*item.unscope_values)
             scope.where_values += item.where_values
             scope.bind_values  += item.bind_values
             scope.order_values |= item.order_values

data/lib/active_record/associations/belongs_to_association.rb

@@ -68,7 +68,7 @@ module ActiveRecord
         def increment_counter(counter_cache_name)
           if foreign_key_present?
             klass.increment_counter(counter_cache_name, target_id)
-            if target && !stale_target?
+            if target && !stale_target? && counter_cache_available_in_memory?(counter_cache_name)
               target.increment(counter_cache_name)
             end
           end
@@ -110,6 +110,10 @@ module ActiveRecord
           result = owner._read_attribute(reflection.foreign_key)
           result && result.to_s
         end
+
+        def counter_cache_available_in_memory?(counter_cache_name)
+          target.respond_to?(counter_cache_name)
+        end
     end
   end
 end

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

@@ -21,7 +21,7 @@ module ActiveRecord::Associations::Builder
     end
     self.extensions = []
 
-    self.valid_options = [:class_name, :class, :foreign_key, :validate]
+    self.valid_options = [:class_name, :anonymous_class, :foreign_key, :validate]
 
     attr_reader :name, :scope, :options
 

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

@@ -46,7 +46,7 @@ module ActiveRecord::Associations::Builder
 
       join_model = Class.new(ActiveRecord::Base) {
         class << self;
-          attr_accessor :class_resolver
+          attr_accessor :left_model
           attr_accessor :name
           attr_accessor :table_name_resolver
           attr_accessor :left_reflection
@@ -58,7 +58,7 @@ module ActiveRecord::Associations::Builder
         end
 
         def self.compute_type(class_name)
-          class_resolver.compute_type class_name
+          left_model.compute_type class_name
         end
 
         def self.add_left_association(name, options)
@@ -72,13 +72,17 @@ module ActiveRecord::Associations::Builder
           self.right_reflection = _reflect_on_association(rhs_name)
         end
 
+        def self.retrieve_connection
+          left_model.retrieve_connection
+        end
+
       }
 
       join_model.name                = "HABTM_#{association_name.to_s.camelize}"
       join_model.table_name_resolver = habtm
-      join_model.class_resolver      = lhs_model
+      join_model.left_model          = lhs_model
 
-      join_model.add_left_association :left_side, class: lhs_model
+      join_model.add_left_association :left_side, anonymous_class: lhs_model
       join_model.add_right_association association_name, belongs_to_options(options)
       join_model
     end

data/lib/active_record/associations/collection_association.rb

@@ -431,13 +431,7 @@ module ActiveRecord
 
       private
       def get_records
-        if reflection.scope_chain.any?(&:any?) ||
-          scope.eager_loading? ||
-          klass.current_scope ||
-          klass.default_scopes.any?
-
-          return scope.to_a
-        end
+        return scope.to_a if skip_statement_cache?
 
         conn = klass.connection
         sc = reflection.association_scope_cache(conn, owner) do

data/lib/active_record/associations/collection_proxy.rb

@@ -470,15 +470,16 @@ module ActiveRecord
         @association.destroy_all
       end
 
-      # Deletes the +records+ supplied and removes them from the collection. For
-      # +has_many+ associations, the deletion is done according to the strategy
-      # specified by the <tt>:dependent</tt> option. Returns an array with the
+      # Deletes the +records+ supplied from the collection according to the strategy
+      # specified by the +:dependent+ option. If no +:dependent+ option is given,
+      # then it will follow the default strategy. Returns an array with the
       # deleted records.
       #
-      # If no <tt>:dependent</tt> option is given, then it will follow the default
-      # strategy. The default strategy is <tt>:nullify</tt>. This sets the foreign
-      # keys to <tt>NULL</tt>. For, +has_many+ <tt>:through</tt>, the default
-      # strategy is +delete_all+.
+      # For +has_many :through+ associations, the default deletion strategy is
+      # +:delete_all+.
+      #
+      # For +has_many+ associations, the default deletion strategy is +:nullify+.
+      # This sets the foreign keys to +NULL+.
       #
       #   class Person < ActiveRecord::Base
       #     has_many :pets # dependent: :nullify option by default

data/lib/active_record/associations/has_many_association.rb

@@ -80,8 +80,15 @@ module ActiveRecord
           [association_scope.limit_value, count].compact.min
         end
 
+
+        # Returns whether a counter cache should be used for this association.
+        #
+        # The counter_cache option must be given on either the owner or inverse
+        # association, and the column must be present on the owner.
         def has_cached_counter?(reflection = reflection())
-          owner.attribute_present?(cached_counter_attribute_name(reflection))
+          if reflection.options[:counter_cache] || (inverse = inverse_which_updates_counter_cache(reflection)) && inverse.options[:counter_cache]
+            owner.attribute_present?(cached_counter_attribute_name(reflection))
+          end
         end
 
         def cached_counter_attribute_name(reflection = reflection())

data/lib/active_record/associations/has_many_through_association.rb

@@ -94,6 +94,11 @@ module ActiveRecord
 
             through_record = through_association.build(*options_for_through_record)
             through_record.send("#{source_reflection.name}=", record)
+
+            if options[:source_type]
+              through_record.send("#{source_reflection.foreign_type}=", options[:source_type])
+            end
+
             through_record
           end
         end
@@ -229,6 +234,10 @@ module ActiveRecord
           false
         end
 
+        def has_cached_counter?(reflection = reflection())
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
         def through_reflection_updates_counter_cache?
           counter_name = cached_counter_attribute_name
           inverse_updates_counter_named?(counter_name, through_reflection)

data/lib/active_record/associations/join_dependency.rb

@@ -151,7 +151,8 @@ module ActiveRecord
 
         message_bus.instrument('instantiation.active_record', payload) do
           result_set.each { |row_hash|
-            parent = parents[row_hash[primary_key]] ||= join_root.instantiate(row_hash, column_aliases)
+            parent_key = primary_key ? row_hash[primary_key] : row_hash
+            parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases)
             construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
           }
         end
@@ -233,6 +234,7 @@ module ActiveRecord
       end
 
       def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+        return if ar_parent.nil?
         primary_id  = ar_parent.id
 
         parent.children.each do |node|
@@ -249,7 +251,11 @@ module ActiveRecord
 
           key = aliases.column_alias(node, node.primary_key)
           id = row[key]
-          next if id.nil?
+          if id.nil?
+            nil_association = ar_parent.association(node.reflection.name)
+            nil_association.loaded!
+            next
+          end
 
           model = seen[parent.base_klass][primary_id][node.base_klass][id]
 

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

@@ -145,6 +145,10 @@ module ActiveRecord
           scope.joins! preload_values[:joins] || values[:joins]
           scope.order! preload_values[:order] || values[:order]
 
+          if preload_values[:reordering] || values[:reordering]
+            scope.reordering_value = true
+          end
+
           if preload_values[:readonly] || values[:readonly]
             scope.readonly!
           end
@@ -153,7 +157,7 @@ module ActiveRecord
             scope.where!(klass.table_name => { reflection.type => model.base_class.sti_name })
           end
 
-          scope.unscope_values = Array(values[:unscope])
+          scope.unscope_values = Array(values[:unscope]) + Array(preload_values[:unscope])
           klass.default_scoped.merge(scope)
         end
       end