activerecord 4.0.0 → 4.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 76ddb57b66b29722a983d38eba75ebc3e94610ea
-  data.tar.gz: 743a630e5e1722c2655ca8c167dbb5be2ab49afb
+  metadata.gz: 5c7b681afcb7c78e77f49102c88638d86f8da054
+  data.tar.gz: ea168d9889ba754dd4569410d613b6ea79c04b57
 SHA512:
-  metadata.gz: a643a5988de90b3145ab259ecc0f20acba5e66db188ad8ebfbdd12e14352e26d696faf570cc04c2da30e70bc1a490d9107cb4086f59b90614088941c96f095e3
-  data.tar.gz: 513f56748c0e72bc073a068f29846737aeb95c11fd3fc23672295027a6d475c2764613f3b1653cdb8d32ac61b4dfcff32cade6279fad13ad4030bd1e01e536b0
+  metadata.gz: 08a6d5f0dbe0186a931fe72a9f1ff7d5380b211ad11fc1a2037adf9abf3fb34b5af8df245b9569db37bcbe86b3c1dd17a444681c2cb9ac97c5b9a21ef088348a
+  data.tar.gz: fb894bd5fa52bf9bb37de1eeb90aacf59587e61f55577c478a0b665758a1d6b0328f9400f9fcd9c170abf2e005151a8d6ec30d5e9a08c056920308278fbf990a

data/CHANGELOG.md

@@ -1,3 +1,328 @@
+## Rails 4.0.1 (November 01, 2013) ##
+
+*   `NullRelation#pluck` takes a list of columns
+
+    The method signature in `NullRelation` was updated to mimic that in
+    `Calculations`.
+
+    *Derek Prior*
+
+*   `scope_chain` should not be mutated for other reflections.
+
+    Currently `scope_chain` uses same array for building different
+    `scope_chain` for different associations. During processing
+    these arrays are sometimes mutated and because of in-place
+    mutation the changed `scope_chain` impacts other reflections.
+
+    Fix is to dup the value before adding to the `scope_chain`.
+
+    Fixes #3882.
+
+    *Neeraj Singh*
+
+*   Prevent the inversed association from being reloaded on save.
+
+    Fixes #9499.
+
+    *Dmitry Polushkin*
+
+*   `Relation#order` quotes the column name if you pass a `Symbol`.
+    Fixes #11870.
+
+    Example:
+
+        # Before
+        Post.order(:id).to_sql == '... ORDER BY "posts".id ASC'
+
+        # After
+        Post.order(:id).to_sql == '... ORDER BY "posts"."id" ASC'
+
+    *Yves Senn*
+
+*   Generate subquery for `Relation` if it passed as array condition for `where`
+    method.
+
+    Example:
+
+        # Before
+        Blog.where('id in (?)', Blog.where(id: 1))
+        # =>  SELECT "blogs".* FROM "blogs"  WHERE "blogs"."id" = 1
+        # =>  SELECT "blogs".* FROM "blogs"  WHERE (id IN (1))
+
+        # After
+        Blog.where('id in (?)', Blog.where(id: 1).select(:id))
+        # =>  SELECT "blogs".* FROM "blogs"
+        #     WHERE "blogs"."id" IN (SELECT "blogs"."id" FROM "blogs"  WHERE "blogs"."id" = 1)
+
+    Fixes #12415.
+
+    *Paul Nikitochkin*
+
+*   For missed association exception message
+    which is raised in `ActiveRecord::Associations::Preloader` class
+    added owner record class name in order to simplify to find problem code.
+
+    *Paul Nikitochkin*
+
+*   Fixes bug when using includes combined with select, the select statement was overwritten.
+
+    Fixes #11773.
+
+    *Edo Balvers*
+
+*   Objects instantiated using a null relationship will now retain the
+    attributes of the where clause.
+
+    Fixes #11676, #11675, #11376.
+
+    *Paul Nikitochkin*, *Peter Brown*, *Nthalk*
+
+*   Fixed `ActiveRecord::Associations::CollectionAssociation#find`
+    when using `has_many` association with `:inverse_of` and finding an array of one element,
+    it should return an array of one element too.
+
+    *arthurnn*
+
+*   Callbacks on has_many should access the in memory parent if a inverse_of is set.
+
+    *arthurnn*
+
+*   Migration dump UUID default functions to schema.rb.
+
+    Fixes #10751.
+
+    *kennyj*
+
+*   Fixed a bug in `ActiveRecord::Associations::CollectionAssociation#find_by_scan`
+    when using `has_many` association with `:inverse_of` option and UUID primary key.
+
+    Fixes #10450.
+
+    *kennyj*
+
+*   Fix: joins association, with defined in the scope block constraints by using several
+    where constraints and at least of them is not `Arel::Nodes::Equality`,
+    generates invalid SQL expression.
+
+    Fixes: #11963
+
+    *Paul Nikitochkin*
+
+*   Make possible to run SQLite rake tasks without the `Rails` constant defined.
+
+    *Damien Mathieu*
+
+*   Allow Relation#from to accept other relations with bind values.
+
+    *Ryan Wallace*
+
+*   Make `find_in_batches` and `find_each` work without a logger.
+
+    *Dmitry Polushkin*
+
+*   Fix inserts with prepared statements disabled.
+
+    Fixes #12023.
+
+    *Rafael Mendonça França*
+
+*   Setting a has_one association on a new record no longer causes an empty
+    transaction.
+
+    *Dylan Thacker-Smith*
+
+*   Fix `AR::Relation#merge` sometimes failing to preserve `readonly(false)` flag.
+
+    *thedarkone*
+
+*   PostgreSQL adapter recognizes negative money values formatted with
+    parentheses (eg. `($1.25) # => -1.25`)).
+    Fixes #11899.
+
+    * Yves Senn*
+
+*   Do not load all child records for inverse case.
+
+    currently `post.comments.find(Comment.first.id)` would load all
+    comments for the given post to set the inverse association.
+
+    This has a huge performance penalty. Because if post has 100k
+    records and all these 100k records would be loaded in memory
+    even though the comment id was supplied.
+
+    Fix is to use in-memory records only if loaded? is true. Otherwise
+    load the records using full sql.
+
+    Fixes #10509.
+
+    *Neeraj Singh*
+
+*   `ActiveRecord::FinderMethods#exists?` returns `true`/`false` in all cases.
+
+    *Xavier Noria*
+
+*   Load fixtures from linked folders.
+
+    *Kassio Borges*
+
+*   Create a directory for sqlite3 file if not present on the system.
+
+    *Richard Schneeman*
+
+*   Removed redundant override of `xml` column definition for PG,
+    in order to use `xml` column type instead of `text`.
+
+    *Paul Nikitochkin*, *Michael Nikitochkin*
+
+*   Revert `ActiveRecord::Relation#order` change that make new order
+    prepend the old one.
+
+    Before:
+
+        User.order("name asc").order("created_at desc")
+        # SELECT * FROM users ORDER BY created_at desc, name asc
+
+    After:
+
+        User.order("name asc").order("created_at desc")
+        # SELECT * FROM users ORDER BY name asc, created_at desc
+
+    This also affects order defined in `default_scope` or any kind of associations.
+
+    *Rafael Mendonça França*
+
+*   When using optimistic locking, `update` was not passing the column to `quote_value`
+    to allow the connection adapter to properly determine how to quote the value. This was
+    affecting certain databases that use specific column types.
+
+    Fixes #6763.
+
+    *Alfred Wong*
+
+*   `change_column` for PostgreSQL adapter respects the `:array` option.
+
+    *Yves Senn*
+
+*   Fixes bug introduced by #3329. Now, when autosaving associations,
+    deletions happen before inserts and saves. This prevents a
+    'duplicate unique value' database error that would occur if a record being created had
+    the same value on a unique indexed field as that of a record being destroyed.
+
+    *Johnny Holton*
+
+*   Flatten merged join values before building the joins.
+
+    While joining values special treatment is given to string values.
+    By flattening the array it ensures that string values are detected
+    as strings and not arrays.
+
+    Fixes #10669.
+
+    *Neeraj Singh and iwiznia*
+
+*   Remove extra select and update queries on `save`/`touch`/`destroy` Active Record model
+    with belongs to reflection with option `touch: true`.
+
+    Fixes #11288.
+
+    *Paul Nikitochkin*
+
+*   Support array as root element in JSON fields.
+
+    *Alexey Noskov & Francesco Rodriguez*
+
+*   Apply default scope when joining associations. For example:
+
+        class Post < ActiveRecord::Base
+          default_scope -> { where published: true }
+        end
+
+        class Comment
+          belongs_to :post
+        end
+
+    When calling `Comment.joins(:post)`, we expect to receive only
+    comments on published posts, since that is the default scope for
+    posts.
+
+    Before this change, the default scope from `Post` was not applied,
+    so we'd get comments on unpublished posts.
+
+    *Jon Leighton*
+
+*   `inspect` on Active Record model classes does not initiate a
+    new connection. This means that calling `inspect`, when the
+    database is missing, will no longer raise an exception.
+
+    Fixes #10936.
+
+    Example:
+
+        Author.inspect # => "Author(no database connection)"
+
+    *Yves Senn*
+
+*   Fix mysql2 adapter raises the correct exception when executing a query on a
+    closed connection.
+
+    *Yves Senn*
+
+*   Fix the `:primary_key` option for `has_many` associations.
+
+    Fixes #10693.
+
+    *Yves Senn*
+
+*   Fix bug where tiny types are incorectly coerced as booleand when the length is more than 1.
+
+    Fixes #10620.
+
+    *Aaron Patterson*
+
+*   Also support extensions in PostgreSQL 9.1. This feature has been supported since 9.1.
+
+    *kennyj*
+
+*   Deprecate `ConnectionAdapters::SchemaStatements#distinct`,
+    as it is no longer used by internals.
+
+    *Ben Woosley#
+
+*   Remove not needed bind variables. Port of commit #5082345.
+
+    Fixes #10958.
+
+    *Neeraj Singh*
+
+*   Confirm a record has not already been destroyed before decrementing counter cache.
+
+    *Ben Tucker*
+
+*   Fixed a bug in `ActiveRecord#sanitize_sql_hash_for_conditions` in which
+    `self.class` is an argument to `PredicateBuilder#build_from_hash`
+    causing `PredicateBuilder` to call non-existent method
+    `Class#reflect_on_association`.
+
+    *Zach Ohlgren*
+
+*   While removing index if column option is missing then raise IrreversibleMigration exception.
+
+    Following code should raise `IrreversibleMigration`. But the code was
+    failing since options is an array and not a hash.
+
+        def change
+          change_table :users do |t|
+            t.remove_index [:name, :email]
+          end
+        end
+
+    Fix was to check if the options is a Hash before operating on it.
+
+    Fixes #10419.
+
+    *Neeraj Singh*
+
+
 ## Rails 4.0.0 (June 25, 2013) ##
 
 *   Fix `add_column` with `array` option when using PostgreSQL. Fixes #10432
@@ -30,7 +355,6 @@
 
     *Adam Anderson*
 
-
 *   Fix pending migrations error when loading schema and `ActiveRecord::Base.table_name_prefix`
     is not blank.
 
@@ -2046,7 +2370,7 @@
 *   The primary key is always initialized in the @attributes hash to `nil` (unless
     another value has been specified).
 
-    *Aaron Paterson*
+    *Aaron Patterson*
 
 *   In previous releases, the following would generate a single query with
     an `OUTER JOIN comments`, rather than two separate queries:
@@ -2098,5 +2422,4 @@
 
     *Aaron Patterson*
 
-
 Please check [3-2-stable](https://github.com/rails/rails/blob/3-2-stable/activerecord/CHANGELOG.md) for previous changes.

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/4-0-stable/activerecord
 
 
 == License

data/lib/active_record/association_relation.rb

@@ -0,0 +1,18 @@
+module ActiveRecord
+  class AssociationRelation < Relation
+    def initialize(klass, table, association)
+      super(klass, table)
+      @association = association
+    end
+
+    def proxy_association
+      @association
+    end
+
+    private
+
+    def exec_queries
+      super.each { |r| @association.set_inverse_instance r }
+    end
+  end
+end

data/lib/active_record/associations/association.rb

@@ -18,6 +18,7 @@ module ActiveRecord
     #         HasManyThroughAssociation + ThroughAssociation
     class Association #:nodoc:
       attr_reader :owner, :target, :reflection
+      attr_accessor :inversed
 
       delegate :options, :to => :reflection
 
@@ -43,6 +44,7 @@ module ActiveRecord
         @loaded = false
         @target = nil
         @stale_state = nil
+        @inversed = false
       end
 
       # Reloads the \target and returns +self+ on success.
@@ -60,8 +62,9 @@ module ActiveRecord
 
       # Asserts the \target has been loaded setting the \loaded flag to +true+.
       def loaded!
-        @loaded      = true
+        @loaded = true
         @stale_state = stale_state
+        @inversed = false
       end
 
       # The target is stale if the target no longer points to the record(s) that the
@@ -71,7 +74,7 @@ module ActiveRecord
       #
       # Note that if the target has not been loaded, it is not considered stale.
       def stale_target?
-        loaded? && @stale_state != stale_state
+        !inversed && loaded? && @stale_state != stale_state
       end
 
       # Sets the target of this association to <tt>\target</tt>, and the \loaded flag to +true+.
@@ -110,6 +113,7 @@ module ActiveRecord
         if record && invertible_for?(record)
           inverse = record.association(inverse_reflection_for(record).name)
           inverse.target = owner
+          inverse.inversed = true
         end
       end
 
@@ -122,7 +126,11 @@ module ActiveRecord
       # Can be overridden (i.e. in ThroughAssociation) to merge in other scopes (i.e. the
       # through association's scope)
       def target_scope
-        klass.all
+        all = klass.all
+        scope = AssociationRelation.new(klass, klass.arel_table, self)
+        scope.merge! all
+        scope.default_scoped = all.default_scoped?
+        scope
       end
 
       # Loads the \target if needed and returns it.

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

@@ -34,7 +34,9 @@ module ActiveRecord::Associations::Builder
         def belongs_to_counter_cache_before_destroy_for_#{name}
           unless destroyed_by_association && destroyed_by_association.foreign_key.to_sym == #{foreign_key.to_sym.inspect}
             record = #{name}
-            record.class.decrement_counter(:#{cache_column}, record.id) unless record.nil?
+            if record && !self.destroyed?
+              record.class.decrement_counter(:#{cache_column}, record.id)
+            end
           end
         end
 
@@ -68,7 +70,7 @@ module ActiveRecord::Associations::Builder
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def belongs_to_touch_after_save_or_destroy_for_#{name}
           foreign_key_field = #{reflection.foreign_key.inspect}
-          old_foreign_id    = attribute_was(foreign_key_field)
+          old_foreign_id    = changed_attributes[foreign_key_field]
 
           if old_foreign_id
             klass      = association(#{name.inspect}).klass

data/lib/active_record/associations/collection_association.rb

@@ -81,15 +81,15 @@ module ActiveRecord
         else
           if options[:finder_sql]
             find_by_scan(*args)
-          elsif options[:inverse_of]
-            args = args.flatten
-            raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args.blank?
+          elsif options[:inverse_of] && loaded?
+            args_flatten = args.flatten
+            raise RecordNotFound, "Couldn't find #{scope.klass.name} without an ID" if args_flatten.blank?
 
             result = find_by_scan(*args)
 
             result_size = Array(result).size
-            if !result || result_size != args.size
-              scope.raise_record_not_found_exception!(args, result_size, args.size)
+            if !result || result_size != args_flatten.size
+              scope.raise_record_not_found_exception!(args_flatten, result_size, args_flatten.size)
             else
               result
             end
@@ -583,14 +583,14 @@ module ActiveRecord
         # specified, then #find scans the entire collection.
         def find_by_scan(*args)
           expects_array = args.first.kind_of?(Array)
-          ids           = args.flatten.compact.map{ |arg| arg.to_i }.uniq
+          ids           = args.flatten.compact.map{ |arg| arg.to_s }.uniq
 
           if ids.size == 1
             id = ids.first
-            record = load_target.detect { |r| id == r.id }
+            record = load_target.detect { |r| id == r.id.to_s }
             expects_array ? [ record ] : record
           else
-            load_target.select { |r| ids.include?(r.id) }
+            load_target.select { |r| ids.include?(r.id.to_s) }
           end
         end
 

data/lib/active_record/associations/collection_proxy.rb

@@ -830,7 +830,7 @@ module ActiveRecord
       #   person.pets.include?(Pet.find(20)) # => true
       #   person.pets.include?(Pet.find(21)) # => false
       def include?(record)
-        @association.include?(record)
+        !!@association.include?(record)
       end
 
       def proxy_association
@@ -847,9 +847,7 @@ module ActiveRecord
 
       # Returns a <tt>Relation</tt> object for the records in this association
       def scope
-        @association.scope.tap do |scope|
-          scope.proxy_association = @association
-        end
+        @association.scope
       end
 
       # :nodoc:

data/lib/active_record/associations/has_many_association.rb

@@ -32,6 +32,7 @@ module ActiveRecord
 
       def insert_record(record, validate = true, raise = false)
         set_owner_attributes(record)
+        set_inverse_instance(record)
 
         if raise
           record.save!(:validate => validate)
@@ -115,8 +116,7 @@ module ActiveRecord
             if records == :all
               scope = self.scope
             else
-              keys  = records.map { |r| r[reflection.association_primary_key] }
-              scope = self.scope.where(reflection.association_primary_key => keys)
+              scope = self.scope.where(reflection.klass.primary_key => records)
             end
 
             if method == :delete_all

data/lib/active_record/associations/has_one_association.rb

@@ -27,6 +27,8 @@ module ActiveRecord
 
         return self.target if !(target || record)
         if (target != record) || record.changed?
+          save &&= owner.persisted?
+
           transaction_if(save) do
             remove_target!(options[:dependent]) if target && !target.destroyed?
 
@@ -34,7 +36,7 @@ module ActiveRecord
               set_owner_attributes(record)
               set_inverse_instance(record)
 
-              if owner.persisted? && save && !record.save
+              if save && !record.save
                 nullify_owner_attributes(record)
                 set_owner_attributes(target) if target
                 raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."

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

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

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

@@ -62,7 +62,20 @@ module ActiveRecord
         end
 
         def extract_record(row)
-          Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
+          # This code is performance critical as it is called per row.
+          # see: https://github.com/rails/rails/pull/12185
+          hash = {}
+
+          index = 0
+          length = column_names_with_alias.length
+
+          while index < length
+            column_name, alias_name = column_names_with_alias[index]
+            hash[column_name] = row[alias_name]
+            index += 1
+          end
+
+          hash
         end
 
         def record_id(row)

data/lib/active_record/associations/preloader.rb

@@ -141,10 +141,11 @@ module ActiveRecord
 
       def records_by_reflection(association)
         records.group_by do |record|
-          reflection = record.class.reflections[association]
+          record_class = record.class
+          reflection = record_class.reflections[association]
 
           unless reflection
-            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found; " \
+            raise ActiveRecord::ConfigurationError, "Association named '#{association}' was not found on #{record_class.name}; " \
                                                     "perhaps you misspelled it?"
           end
 

data/lib/active_record/attribute_methods/read.rb

@@ -33,8 +33,11 @@ module ActiveRecord
         protected
 
         # We want to generate the methods via module_eval rather than
-        # define_method, because define_method is slower on dispatch and
-        # uses more memory (because it creates a closure).
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
         #
         # But sometimes the database might return columns with
         # characters that are not allowed in normal method names (like
@@ -49,6 +52,8 @@ module ActiveRecord
         # key the @attributes_cache in read_attribute.
         def define_method_attribute(name)
           safe_name = name.unpack('h*').first
+          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+
           generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def __temp__#{safe_name}
               read_attribute(AttrNames::ATTR_#{safe_name}) { |n| missing_attribute(n, caller) }
@@ -77,13 +82,14 @@ module ActiveRecord
         # We use #[] first as a perf optimization for non-nil values. See https://gist.github.com/jonleighton/3552829.
         name = attr_name.to_s
         @attributes_cache[name] || @attributes_cache.fetch(name) {
-          column = @columns_hash.fetch(name) {
-            return @attributes.fetch(name) {
-              if name == 'id' && self.class.primary_key != name
-                read_attribute(self.class.primary_key)
-              end
-            }
-          }
+          column = @column_types_override[name] if @column_types_override
+          column ||= @column_types[name]
+
+          return @attributes.fetch(name) {
+            if name == 'id' && self.class.primary_key != name
+              read_attribute(self.class.primary_key)
+            end
+          } unless column
 
           value = @attributes.fetch(name) {
             return block_given? ? yield(name) : nil

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -51,7 +51,7 @@ module ActiveRecord
         def create_time_zone_conversion_attribute?(name, column)
           time_zone_aware_attributes &&
             !self.skip_time_zone_conversion_for_attributes.include?(name.to_sym) &&
-            [:datetime, :timestamp].include?(column.type)
+            (:datetime == column.type || :timestamp == column.type)
         end
       end
     end

data/lib/active_record/attribute_methods/write.rb

@@ -14,6 +14,8 @@ module ActiveRecord
         # this code.
         def define_method_attribute=(name)
           safe_name = name.unpack('h*').first
+          generated_attribute_methods::AttrNames.set_name_cache safe_name, name
+
           generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
             def __temp__#{safe_name}=(value)
               write_attribute(AttrNames::ATTR_#{safe_name}, value)