activerecord 4.2.0 → 4.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 255759d343183e4336a3b6262171fca30de612a5
-  data.tar.gz: 1dcb8b8793917f0b6e382fe0949b10181f53de54
+  metadata.gz: 8e94e5a7efd7f7b5d6f6c4f54ab7f550aceb8a74
+  data.tar.gz: 0642a120174b46d9b9df4fb80b054d8b1910ec0e
 SHA512:
-  metadata.gz: 6d60768a4a480308e1dbf734ca128c2016dac4503f7f090d2ae47931e5f6a6fcb2daf7c4c984bdd870656c732bd976289cc647ef23ffa33738322539b72b51f3
-  data.tar.gz: e9bd572c50583b55611e1ad470f6879600a67f1110a60e6ad09e608885a59c0878f7bd6612ee33fa9c73a89ccebed864827d5a559c22986a1835f88f6ecb0a66
+  metadata.gz: 87d989e4855aaf884a0cb976e27ee3b2f31087042da42335606a6b8cfb29fb50091cd761335caf4b56520a4c54ed9ab349939cedbbec057912f164f355ea6f39
+  data.tar.gz: 51233b959dbacb3e288c7aaa22bc60a7e649c7de1d92fad811e42122eb9686375eddec10867266dcfdf520ab3a3a89edc93c76a1164d322e7445e93a9bab6383

data/CHANGELOG.md

@@ -1,3 +1,217 @@
+## Rails 4.2.1 (March 19, 2014) ##
+
+*   Fixed ActiveRecord::Relation#becomes! and changed_attributes issues for type column
+
+    Fixes #17139.
+
+    *Miklos Fazekas*
+
+*   `remove_reference` with `foreign_key: true` removes the foreign key before
+    removing the column. This fixes a bug where it was not possible to remove
+    the column on MySQL.
+
+    Fixes #18664.
+
+    *Yves Senn*
+
+*   Add a `:foreign_key` option to `references` and associated migration
+    methods. The model and migration generators now use this option, rather than
+    the `add_foreign_key` form.
+
+    *Sean Griffin*
+
+*   Fix rounding problem for PostgreSQL timestamp column.
+
+    If timestamp column have the precision, it need to format according to
+    the precision of timestamp column.
+
+    *Ryuta Kamizono*
+
+*   Respect the database default charset for `schema_migrations` table.
+
+    The charset of `version` column in `schema_migrations` table is depend
+    on the database default charset and collation rather than the encoding
+    of the connection.
+
+    *Ryuta Kamizono*
+
+*   Respect custom primary keys for associations when calling `Relation#where`
+
+    Fixes #18813.
+
+    *Sean Griffin*
+
+*   Fixed several edge cases which could result in a counter cache updating
+    twice or not updating at all for `has_many` and `has_many :through`.
+
+    Fixes #10865.
+
+    *Sean Griffin*
+
+*   Foreign keys added by migrations were given random, generated names. This
+    meant a different `structure.sql` would be generated every time a developer
+    ran migrations on their machine.
+
+    The generated part of foreign key names is now a hash of the table name and
+    column name, which is consistent every time you run the migration.
+
+    *Chris Sinjakli*
+
+*   Fixed ActiveRecord::Relation#group method when argument is SQL reserved key word:
+
+      SplitTest.group(:key).count
+      Property.group(:value).count
+
+    *Bogdan Gusiev*
+
+*   Don't define autosave association callbacks twice from
+    `accepts_nested_attributes_for`.
+
+    Fixes #18704.
+
+    *Sean Griffin*
+
+*   Integer types will no longer raise a `RangeError` when assigning an
+    attribute, but will instead raise when going to the database.
+
+    Fixes several vague issues which were never reported directly. See the
+    commit message from the commit which added this line for some examples.
+
+    *Sean Griffin*
+
+*   Values which would error while being sent to the database (such as an
+    ASCII-8BIT string with invalid UTF-8 bytes on Sqlite3), no longer error on
+    assignment. They will still error when sent to the database, but you are
+    given the ability to re-assign it to a valid value.
+
+    Fixes #18580.
+
+    *Sean Griffin*
+
+*   Don't remove join dependencies in `Relation#exists?`
+
+    Fixes #18632.
+
+    *Sean Griffin*
+
+*   Invalid values assigned to a JSON column are assumed to be `nil`.
+
+    Fixes #18629.
+
+    *Sean Griffin*
+
+*   No longer issue deprecation warning when including a scope with extensions.
+    Previously every scope with extension methods was transformed into an
+    instance dependent scope. Including such a scope would wrongfully issue a
+    deprecation warning. This is no longer the case.
+
+    Fixes #18467.
+
+    *Yves Senn*
+
+*   Correctly use the type provided by `serialize` when updating records using
+    optimistic locking.
+
+    Fixes #18385.
+
+    *Sean Griffin*
+
+*   `attribute_will_change!` will no longer cause non-persistable attributes to
+    be sent to the database.
+
+    Fixes #18407.
+
+    *Sean Griffin*
+
+*   Format the datetime string according to the precision of the datetime field.
+
+    Incompatible to rounding behavior between MySQL 5.6 and earlier.
+
+    In 5.5, when you insert `2014-08-17 12:30:00.999999` the fractional part
+    is ignored. In 5.6, it's rounded to `2014-08-17 12:30:01`:
+
+    http://bugs.mysql.com/bug.php?id=68760
+
+    *Ryuta Kamizono*
+
+*   Allow precision option for MySQL datetimes.
+
+    *Ryuta Kamizono*
+
+*   Clear query cache on rollback.
+
+    *Florian Weingarten*
+
+*   Fixed setting of foreign_key for through associations while building of new record.
+
+    Fixes #12698.
+
+    *Ivan Antropov*
+
+*   Fixed automatic inverse_of for models nested in module.
+
+    *Andrew McCloud*
+
+*   Fix `reaping_frequency` option when the value is a string.
+
+    This usually happens when it is configured using `DATABASE_URL`.
+
+    *korbin*
+
+*   Fix error message when trying to create an associated record and the foreign
+    key is missing.
+
+    Before this fix the following exception was being raised:
+
+        NoMethodError: undefined method `val' for #<Arel::Nodes::BindParam:0x007fc64d19c218>
+
+    Now the message is:
+
+        ActiveRecord::UnknownAttributeError: unknown attribute 'foreign_key' for Model.
+
+    *Rafael Mendonça França*
+
+*   Fix change detection problem for PostgreSQL bytea type and
+    `ArgumentError: string contains null byte` exception with pg-0.18.
+
+    Fixes #17680.
+
+    *Lars Kanis*
+
+*   When a table has a composite primary key, the `primary_key` method for
+    SQLite3 and PostgreSQL adapters was only returning the first field of the key.
+    Ensures that it will return nil instead, as Active Record doesn't support
+    composite primary keys.
+
+    Fixes #18070.
+
+    *arthurnn*
+
+*   Ensure `first!` and friends work on loaded associations.
+
+    Fixes #18237.
+
+    *Sean Griffin*
+
+*   Dump the default `nil` for PostgreSQL UUID primary key.
+
+    *Ryuta Kamizono*
+
+*   Don't raise when writing an attribute with an out-of-range datetime passed
+    by the user.
+
+    *Grey Baker*
+
+*   Fixes bug with 'ActiveRecord::Type::Numeric' that causes negative values to
+    be marked as having changed when set to the same negative value.
+
+    Fixes #18161.
+
+    *Daniel Fox*
+
+
+## Rails 4.2.0 (December 20, 2014) ##
+
 *   Introduce `force: :cascade` option for `create_table`. Using this option
     will recreate tables even if they have dependent objects (like foreign keys).
     `db/schema.rb` now uses `force: :cascade`. This makes it possible to
@@ -9,7 +223,7 @@
     before loading the schema. This is left for the user to do.
     `db:test:prepare` will still purge the database.
 
-    Closes #17945.
+    Fixes #17945.
 
     *Yves Senn*
 

data/lib/active_record/associations.rb

@@ -116,6 +116,7 @@ module ActiveRecord
     autoload :Association,           'active_record/associations/association'
     autoload :SingularAssociation,   'active_record/associations/singular_association'
     autoload :CollectionAssociation, 'active_record/associations/collection_association'
+    autoload :ForeignAssociation,    'active_record/associations/foreign_association'
     autoload :CollectionProxy,       'active_record/associations/collection_proxy'
 
     autoload :BelongsToAssociation,            'active_record/associations/belongs_to_association'
@@ -1011,7 +1012,7 @@ module ActiveRecord
     # record(s) being removed so that callbacks are run. However <tt>delete</tt> and <tt>delete_all</tt> will either
     # do the deletion according to the strategy specified by the <tt>:dependent</tt> option, or
     # if no <tt>:dependent</tt> option is given, then it will follow the default strategy.
-    # The default strategy is <tt>:nullify</tt> (set the foreign keys to <tt>nil</tt>), except for
+    # The default strategy is to do nothing (leave the foreign keys with the parent ids set), except for
     # +has_many+ <tt>:through</tt>, where the default strategy is <tt>delete_all</tt> (delete
     # the join records, without running their callbacks).
     #
@@ -1377,7 +1378,7 @@ module ActiveRecord
       #   has_one :last_comment, -> { order 'posted_on' }, class_name: "Comment"
       #   has_one :project_manager, -> { where role: 'project_manager' }, class_name: "Person"
       #   has_one :attachment, as: :attachable
-      #   has_one :boss, readonly: :true
+      #   has_one :boss, -> { readonly }
       #   has_one :club, through: :membership
       #   has_one :primary_address, -> { where primary: true }, through: :addressables, source: :addressable
       #   has_one :credit_card, required: true
@@ -1505,7 +1506,7 @@ module ActiveRecord
       #   belongs_to :valid_coupon, ->(o) { where "discounts > ?", o.payments_count },
       #                             class_name: "Coupon", foreign_key: "coupon_id"
       #   belongs_to :attachable, polymorphic: true
-      #   belongs_to :project, readonly: true
+      #   belongs_to :project, -> { readonly }
       #   belongs_to :post, counter_cache: true
       #   belongs_to :company, touch: true
       #   belongs_to :company, touch: :employees_last_updated_at

data/lib/active_record/associations/belongs_to_association.rb

@@ -68,16 +68,19 @@ module ActiveRecord
         def increment_counter(counter_cache_name)
           if foreign_key_present?
             klass.increment_counter(counter_cache_name, target_id)
+            if target && !stale_target?
+              target.increment(counter_cache_name)
+            end
           end
         end
 
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
-          record.id != owner[reflection.foreign_key]
+          record.id != owner._read_attribute(reflection.foreign_key)
         end
 
         def replace_keys(record)
-          owner[reflection.foreign_key] = record[reflection.association_primary_key(record.class)]
+          owner[reflection.foreign_key] = record._read_attribute(reflection.association_primary_key(record.class))
         end
 
         def remove_keys
@@ -85,7 +88,7 @@ module ActiveRecord
         end
 
         def foreign_key_present?
-          owner[reflection.foreign_key]
+          owner._read_attribute(reflection.foreign_key)
         end
 
         # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
@@ -99,12 +102,13 @@ module ActiveRecord
           if options[:primary_key]
             owner.send(reflection.name).try(:id)
           else
-            owner[reflection.foreign_key]
+            owner._read_attribute(reflection.foreign_key)
           end
         end
 
         def stale_state
-          owner[reflection.foreign_key] && owner[reflection.foreign_key].to_s
+          result = owner._read_attribute(reflection.foreign_key)
+          result && result.to_s
         end
     end
   end

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

@@ -82,7 +82,11 @@ module ActiveRecord::Associations::Builder
 
     def wrap_scope(scope, mod)
       if scope
-        proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        if scope.arity > 0
+          proc { |owner| instance_exec(owner, &scope).extending(mod) }
+        else
+          proc { instance_exec(&scope).extending(mod) }
+        end
       else
         proc { extending(mod) }
       end

data/lib/active_record/associations/collection_association.rb

@@ -129,6 +129,16 @@ module ActiveRecord
         first_nth_or_last(:last, *args)
       end
 
+      def take(n = nil)
+        if loaded?
+          n ? target.take(n) : target.first
+        else
+          scope.take(n).tap do |record|
+            set_inverse_instance record if record.is_a? ActiveRecord::Base
+          end
+        end
+      end
+
       def build(attributes = {}, &block)
         if attributes.is_a?(Array)
           attributes.collect { |attr| build(attr, &block) }
@@ -597,8 +607,13 @@ module ActiveRecord
           if reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
             assoc = owner.association(reflection.through_reflection.name)
             assoc.reader.any? { |source|
-              target = source.send(reflection.source_reflection.name)
-              target.respond_to?(:include?) ? target.include?(record) : target == record
+              target_association = source.send(reflection.source_reflection.name)
+
+              if target_association.respond_to?(:include?)
+                target_association.include?(record)
+              else
+                target_association == record
+              end
             } || target.include?(record)
           else
             target.include?(record)

data/lib/active_record/associations/collection_proxy.rb

@@ -29,6 +29,7 @@ module ActiveRecord
     # instantiation of the actual post records.
     class CollectionProxy < Relation
       delegate(*(ActiveRecord::Calculations.public_instance_methods - [:count]), to: :scope)
+      delegate :find_nth, to: :scope
 
       def initialize(klass, association) #:nodoc:
         @association = association
@@ -226,6 +227,10 @@ module ActiveRecord
         @association.last(*args)
       end
 
+      def take(n = nil)
+        @association.take(n)
+      end
+
       # Returns a new object of the collection type that has been instantiated
       # with +attributes+ and linked to this object, but have not yet been saved.
       # You can pass an array of attributes hashes, this will return an array

data/lib/active_record/associations/foreign_association.rb

@@ -0,0 +1,11 @@
+module ActiveRecord::Associations
+  module ForeignAssociation
+    def foreign_key_present?
+      if reflection.klass.primary_key
+        owner.attribute_present?(reflection.active_record_primary_key)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/active_record/associations/has_many_association.rb

@@ -6,6 +6,7 @@ module ActiveRecord
     # If the association has a <tt>:through</tt> option further specialization
     # is provided by its child HasManyThroughAssociation.
     class HasManyAssociation < CollectionAssociation #:nodoc:
+      include ForeignAssociation
 
       def handle_dependency
         case options[:dependent]
@@ -84,7 +85,11 @@ module ActiveRecord
         end
 
         def cached_counter_attribute_name(reflection = reflection())
-          options[:counter_cache] || "#{reflection.name}_count"
+          if reflection.options[:counter_cache]
+            reflection.options[:counter_cache].to_s
+          else
+            "#{reflection.name}_count"
+          end
         end
 
         def update_counter(difference, reflection = reflection())
@@ -100,7 +105,7 @@ module ActiveRecord
         end
 
         def update_counter_in_memory(difference, reflection = reflection())
-          if has_cached_counter?(reflection)
+          if counter_must_be_updated_by_has_many?(reflection)
             counter = cached_counter_attribute_name(reflection)
             owner[counter] += difference
             owner.send(:clear_attribute_changes, counter) # eww
@@ -117,17 +122,28 @@ module ActiveRecord
         #     it will be decremented twice.
         #
         # Hence this method.
-        def inverse_updates_counter_cache?(reflection = reflection())
+        def inverse_which_updates_counter_cache(reflection = reflection())
           counter_name = cached_counter_attribute_name(reflection)
-          inverse_updates_counter_named?(counter_name, reflection)
+          inverse_which_updates_counter_named(counter_name, reflection)
         end
+        alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
 
-        def inverse_updates_counter_named?(counter_name, reflection = reflection())
-          reflection.klass._reflections.values.any? { |inverse_reflection|
+        def inverse_which_updates_counter_named(counter_name, reflection)
+          reflection.klass._reflections.values.find { |inverse_reflection|
             inverse_reflection.belongs_to? &&
             inverse_reflection.counter_cache_column == counter_name
           }
         end
+        alias inverse_updates_counter_named? inverse_which_updates_counter_named
+
+        def inverse_updates_counter_in_memory?(reflection)
+          inverse = inverse_which_updates_counter_cache(reflection)
+          inverse && inverse == reflection.inverse_of
+        end
+
+        def counter_must_be_updated_by_has_many?(reflection)
+          !inverse_updates_counter_in_memory?(reflection) && has_cached_counter?(reflection)
+        end
 
         def delete_count(method, scope)
           if method == :delete_all
@@ -153,14 +169,6 @@ module ActiveRecord
           end
         end
 
-        def foreign_key_present?
-          if reflection.klass.primary_key
-            owner.attribute_present?(reflection.association_primary_key)
-          else
-            false
-          end
-        end
-
         def concat_records(records, *)
           update_counter_if_success(super, records.length)
         end