activerecord 4.0.0.beta1 → 4.0.0.rc1

data/README.rdoc

@@ -130,7 +130,7 @@ A short rundown of some of the major features:
   SQLite3[link:classes/ActiveRecord/ConnectionAdapters/SQLite3Adapter.html].
 
 
-* Logging support for Log4r[http://log4r.sourceforge.net] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
+* Logging support for Log4r[http://log4r.rubyforge.org] and Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc].
 
     ActiveRecord::Base.logger = ActiveSupport::Logger.new(STDOUT)
     ActiveRecord::Base.logger = Log4r::Logger.new('Application Log')
@@ -190,7 +190,7 @@ The latest version of Active Record can be installed with RubyGems:
 
   % [sudo] gem install activerecord
 
-Source code can be downloaded as part of the Rails project on GitHub
+Source code can be downloaded as part of the Rails project on GitHub:
 
 * https://github.com/rails/rails/tree/master/activerecord
 
@@ -204,7 +204,7 @@ Active Record is released under the MIT license:
 
 == Support
 
-API documentation is at
+API documentation is at:
 
 * http://api.rubyonrails.org
 

data/lib/active_record.rb

@@ -35,8 +35,8 @@ module ActiveRecord
   autoload :Base
   autoload :Callbacks
   autoload :Core
-  autoload :CounterCache
   autoload :ConnectionHandling
+  autoload :CounterCache
   autoload :DynamicMatchers
   autoload :Explain
   autoload :Inheritance
@@ -50,12 +50,14 @@ module ActiveRecord
   autoload :Querying
   autoload :ReadonlyAttributes
   autoload :Reflection
+  autoload :RuntimeRegistry
   autoload :Sanitization
   autoload :Schema
   autoload :SchemaDumper
   autoload :SchemaMigration
   autoload :Scoping
   autoload :Serialization
+  autoload :StatementCache
   autoload :Store
   autoload :Timestamp
   autoload :Transactions
@@ -69,8 +71,8 @@ module ActiveRecord
 
     autoload :Aggregations
     autoload :Associations
-    autoload :AttributeMethods
     autoload :AttributeAssignment
+    autoload :AttributeMethods
     autoload :AutosaveAssociation
 
     autoload :Relation
@@ -143,6 +145,10 @@ module ActiveRecord
     autoload :MySQLDatabaseTasks,  'active_record/tasks/mysql_database_tasks'
     autoload :PostgreSQLDatabaseTasks,
       'active_record/tasks/postgresql_database_tasks'
+
+    autoload :FirebirdDatabaseTasks, 'active_record/tasks/firebird_database_tasks'
+    autoload :SqlserverDatabaseTasks, 'active_record/tasks/sqlserver_database_tasks'
+    autoload :OracleDatabaseTasks, 'active_record/tasks/oracle_database_tasks'
   end
 
   autoload :TestCase

data/lib/active_record/associations.rb

@@ -241,6 +241,7 @@ module ActiveRecord
     #   others.destroy_all                |   X   |    X     |    X
     #   others.find(*args)                |   X   |    X     |    X
     #   others.exists?                    |   X   |    X     |    X
+    #   others.distinct                   |   X   |    X     |    X
     #   others.uniq                       |   X   |    X     |    X
     #   others.reset                      |   X   |    X     |    X
     #
@@ -965,7 +966,7 @@ module ActiveRecord
     # For +has_and_belongs_to_many+, <tt>delete</tt> and <tt>destroy</tt> are the same: they
     # cause the records in the join table to be removed.
     #
-    # For +has_many+, <tt>destroy</tt> and <tt>destory_all</tt> will always call the <tt>destroy</tt> method of the
+    # For +has_many+, <tt>destroy</tt> and <tt>destroy_all</tt> will always call the <tt>destroy</tt> method of the
     # 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.
@@ -987,7 +988,7 @@ module ActiveRecord
     # associated objects themselves. So with +has_and_belongs_to_many+ and +has_many+
     # <tt>:through</tt>, the join records will be deleted, but the associated records won't.
     #
-    # This makes sense if you think about it: if you were to call <tt>post.tags.delete(Tag.find_by_name('food'))</tt>
+    # This makes sense if you think about it: if you were to call <tt>post.tags.delete(Tag.find_by(name: 'food'))</tt>
     # you would want the 'food' tag to be unlinked from the post, rather than for the tag itself
     # to be removed from the database.
     #
@@ -1024,7 +1025,7 @@ module ActiveRecord
       # [collection<<(object, ...)]
       #   Adds one or more objects to the collection by setting their foreign keys to the collection's primary key.
       #   Note that this operation instantly fires update sql without waiting for the save or update call on the
-      #   parent object.
+      #   parent object, unless the parent object is a new record.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by setting their foreign keys to +NULL+.
       #   Objects will be in addition destroyed if they're associated with <tt>dependent: :destroy</tt>,
@@ -1072,6 +1073,9 @@ module ActiveRecord
       #   with +attributes+, linked to this object through a foreign key, and that has already
       #   been saved (if it passed the validation). *Note*: This only works if the base model
       #   already exists in the DB, not if it is a new (unsaved) record!
+      # [collection.create!(attributes = {})]
+      #   Does the same as <tt>collection.create</tt>, but raises <tt>ActiveRecord::RecordInvalid</tt>
+      #   if the record is invalid.
       #
       # (*Note*: +collection+ is replaced with the symbol passed as the first argument, so
       # <tt>has_many :clients</tt> would add among others <tt>clients.empty?</tt>.)
@@ -1093,6 +1097,7 @@ module ActiveRecord
       # * <tt>Firm#clients.exists?(name: 'ACME')</tt> (similar to <tt>Client.exists?(name: 'ACME', firm_id: firm.id)</tt>)
       # * <tt>Firm#clients.build</tt> (similar to <tt>Client.new("firm_id" => id)</tt>)
       # * <tt>Firm#clients.create</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save; c</tt>)
+      # * <tt>Firm#clients.create!</tt> (similar to <tt>c = Client.new("firm_id" => id); c.save!</tt>)
       # The declaration can also include an options hash to specialize the behavior of the association.
       #
       # === Options
@@ -1114,11 +1119,11 @@ module ActiveRecord
       #   similar callbacks may affect the :dependent behavior, and the
       #   :dependent behavior may affect other callbacks.
       #
-      #   * <tt>:destroy</tt> causes all the associated objects to also be destroyed
-      #   * <tt>:delete_all</tt> causes all the asssociated objects to be deleted directly from the database (so callbacks will not execute)
+      #   * <tt>:destroy</tt> causes all the associated objects to also be destroyed.
+      #   * <tt>:delete_all</tt> causes all the associated objects to be deleted directly from the database (so callbacks will not be executed).
       #   * <tt>:nullify</tt> causes the foreign keys to be set to +NULL+. Callbacks are not executed.
-      #   * <tt>:restrict_with_exception</tt> causes an exception to be raised if there are any associated records
-      #   * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there are any associated objects
+      #   * <tt>:restrict_with_exception</tt> causes an exception to be raised if there are any associated records.
+      #   * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there are any associated objects.
       #
       #   If using with the <tt>:through</tt> option, the association on the join model must be
       #   a +belongs_to+, and the records which get deleted are the join records, rather than
@@ -1231,7 +1236,7 @@ module ActiveRecord
       #   its owner is destroyed:
       #
       #   * <tt>:destroy</tt> causes the associated object to also be destroyed
-      #   * <tt>:delete</tt> causes the asssociated object to be deleted directly from the database (so callbacks will not execute)
+      #   * <tt>:delete</tt> causes the associated object to be deleted directly from the database (so callbacks will not execute)
       #   * <tt>:nullify</tt> causes the foreign key to be set to +NULL+. Callbacks are not executed.
       #   * <tt>:restrict_with_exception</tt> causes an exception to be raised if there is an associated record
       #   * <tt>:restrict_with_error</tt> causes an error to be added to the owner if there is an associated object
@@ -1407,6 +1412,8 @@ module ActiveRecord
       # to generate a join table name of "papers_paper_boxes" because of the length of the name "paper_boxes",
       # but it in fact generates a join table name of "paper_boxes_papers". Be aware of this caveat, and use the
       # custom <tt>:join_table</tt> option if you need to.
+      # If your tables share a common prefix, it will only appear once at the beginning. For example,
+      # the tables "catalog_categories" and "catalog_products" generate a join table name of "catalog_categories_products".
       #
       # The join table should not have a primary key or a model associated with it. You must manually generate the
       # join table with a migration such as this:
@@ -1433,7 +1440,7 @@ module ActiveRecord
       #   Adds one or more objects to the collection by creating associations in the join table
       #   (<tt>collection.push</tt> and <tt>collection.concat</tt> are aliases to this method).
       #   Note that this operation instantly fires update sql without waiting for the save or update call on the
-      #   parent object.
+      #   parent object, unless the parent object is a new record.
       # [collection.delete(object, ...)]
       #   Removes one or more objects from the collection by removing their associations from the join table.
       #   This does not destroy the objects.

data/lib/active_record/associations/association.rb

@@ -30,7 +30,7 @@ module ActiveRecord
         reset_scope
       end
 
-      # Returns the name of the table of the related class:
+      # Returns the name of the table of the associated class:
       #
       #   post.comments.aliased_table_name # => "comments"
       #
@@ -92,7 +92,7 @@ module ActiveRecord
       # The scope for this association.
       #
       # Note that the association_scope is merged into the target_scope only when the
-      # scoped method is called. This is because at that point the call may be surrounded
+      # scope method is called. This is because at that point the call may be surrounded
       # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
       # actually gets built.
       def association_scope
@@ -113,7 +113,7 @@ module ActiveRecord
         end
       end
 
-      # This class of the target. belongs_to polymorphic overrides this to look at the
+      # Returns the class of the target. belongs_to polymorphic overrides this to look at the
       # polymorphic_type field on the owner.
       def klass
         reflection.klass
@@ -146,7 +146,7 @@ module ActiveRecord
 
       def interpolate(sql, record = nil)
         if sql.respond_to?(:to_proc)
-          owner.send(:instance_exec, record, &sql)
+          owner.instance_exec(record, &sql)
         else
           sql
         end
@@ -203,7 +203,7 @@ module ActiveRecord
         # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
         # 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)
+        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
@@ -217,7 +217,8 @@ module ActiveRecord
           reflection.inverse_of
         end
 
-        # Is this association invertible? Can be redefined by subclasses.
+        # Returns true if inverse association on the given record needs to be set.
+        # This method is redefined by subclasses.
         def invertible_for?(record)
           inverse_reflection_for(record)
         end
@@ -235,6 +236,7 @@ module ActiveRecord
             skip_assign = [reflection.foreign_key, reflection.type].compact
             attributes = create_scope.except(*(record.changed - skip_assign))
             record.assign_attributes(attributes)
+            set_inverse_instance(record)
           end
         end
     end

data/lib/active_record/associations/association_scope.rb

@@ -22,7 +22,7 @@ module ActiveRecord
       private
 
       def column_for(table_name, column_name)
-        columns = alias_tracker.connection.schema_cache.columns_hash[table_name]
+        columns = alias_tracker.connection.schema_cache.columns_hash(table_name)
         columns[column_name]
       end
 
@@ -101,6 +101,7 @@ module ActiveRecord
 
             scope.includes! item.includes_values
             scope.where_values += item.where_values
+            scope.order_values |= item.order_values
           end
         end
 

data/lib/active_record/associations/belongs_to_association.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
-  # = Active Record Belongs To Associations
+  # = Active Record Belongs To Association
   module Associations
     class BelongsToAssociation < SingularAssociation #:nodoc:
 
@@ -8,7 +8,7 @@ module ActiveRecord
       end
 
       def replace(record)
-        raise_on_type_mismatch(record) if record
+        raise_on_type_mismatch!(record) if record
 
         update_counters(record)
         replace_keys(record)

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -22,7 +22,7 @@ module ActiveRecord
           reflection.polymorphic_inverse_of(record.class)
         end
 
-        def raise_on_type_mismatch(record)
+        def raise_on_type_mismatch!(record)
           # A polymorphic association cannot have a type mismatch, by definition
         end
 

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

@@ -21,23 +21,44 @@ module ActiveRecord::Associations::Builder
 
     def add_counter_cache_callbacks(reflection)
       cache_column = reflection.counter_cache_column
+      foreign_key = reflection.foreign_key
 
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def belongs_to_counter_cache_after_create_for_#{name}
-          record = #{name}
-          record.class.increment_counter(:#{cache_column}, record.id) unless record.nil?
+          if record = #{name}
+            record.class.increment_counter(:#{cache_column}, record.id)
+            @_after_create_counter_called = true
+          end
         end
 
         def belongs_to_counter_cache_before_destroy_for_#{name}
-          unless marked_for_destruction?
+          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?
           end
         end
+
+        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}
+            foreign_key_was = self.#{foreign_key}_was
+            foreign_key = self.#{foreign_key}
+
+            if foreign_key && model.respond_to?(:increment_counter)
+              model.increment_counter(:#{cache_column}, foreign_key)
+            end
+            if foreign_key_was && model.respond_to?(:decrement_counter)
+              model.decrement_counter(:#{cache_column}, foreign_key_was)
+            end
+          end
+        end
       CODE
 
       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)
@@ -46,9 +67,20 @@ module ActiveRecord::Associations::Builder
     def add_touch_callbacks(reflection)
       mixin.class_eval <<-CODE, __FILE__, __LINE__ + 1
         def belongs_to_touch_after_save_or_destroy_for_#{name}
-          record = #{name}
+          foreign_key_field = #{reflection.foreign_key.inspect}
+          old_foreign_id    = attribute_was(foreign_key_field)
+
+          if old_foreign_id
+            klass      = association(#{name.inspect}).klass
+            old_record = klass.find_by(klass.primary_key => old_foreign_id)
 
-          unless record.nil?
+            if old_record
+              old_record.touch #{options[:touch].inspect if options[:touch] != true}
+            end
+          end
+
+          record = #{name}
+          unless record.nil? || record.new_record?
             record.touch #{options[:touch].inspect if options[:touch] != true}
           end
         end

data/lib/active_record/associations/collection_association.rb

@@ -34,7 +34,7 @@ module ActiveRecord
           reload
         end
 
-        CollectionProxy.new(klass, self)
+        @proxy ||= CollectionProxy.new(klass, self)
       end
 
       # Implements the writer method, e.g. foo.items= for Foo.has_many :items
@@ -81,6 +81,18 @@ 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?
+
+            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)
+            else
+              result
+            end
           else
             scope.find(*args)
           end
@@ -174,13 +186,14 @@ module ActiveRecord
 
           reflection.klass.count_by_sql(custom_counter_sql)
         else
-          if association_scope.uniq_value
+          relation = scope
+          if association_scope.distinct_value
             # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
             column_name ||= reflection.klass.primary_key
-            count_options[:distinct] = true
+            relation = relation.distinct
           end
 
-          value = scope.count(column_name, count_options)
+          value = relation.count(column_name)
 
           limit  = options[:limit]
           offset = options[:offset]
@@ -204,6 +217,15 @@ module ActiveRecord
         dependent = options[:dependent]
 
         if records.first == :all
+
+          if dependent && dependent == :destroy
+            message = 'In Rails 4.1 delete_all on associations would not fire callbacks. ' \
+                      'It means if the :dependent option is :destroy then the associated ' \
+                      'records would be deleted without loading and invoking callbacks.'
+
+            ActiveRecord::Base.logger ? ActiveRecord::Base.logger.warn(message) : $stderr.puts(message)
+          end
+
           if loaded? || dependent == :destroy
             delete_or_destroy(load_target, dependent)
           else
@@ -237,14 +259,14 @@ module ActiveRecord
       # +count_records+, which is a method descendants have to provide.
       def size
         if !find_target? || loaded?
-          if association_scope.uniq_value
+          if association_scope.distinct_value
             target.uniq.size
           else
             target.size
           end
         elsif !loaded? && !association_scope.group_values.empty?
           load_target.size
-        elsif !loaded? && !association_scope.uniq_value && target.is_a?(Array)
+        elsif !loaded? && !association_scope.distinct_value && target.is_a?(Array)
           unsaved_records = target.select { |r| r.new_record? }
           unsaved_records.size + count_records
         else
@@ -297,17 +319,18 @@ module ActiveRecord
         end
       end
 
-      def uniq
+      def distinct
         seen = {}
         load_target.find_all do |record|
           seen[record.id] = true unless seen.key?(record.id)
         end
       end
+      alias uniq distinct
 
       # Replace this collection with +other_array+. This will perform a diff
       # and delete/add only records that have changed.
       def replace(other_array)
-        other_array.each { |val| raise_on_type_mismatch(val) }
+        other_array.each { |val| raise_on_type_mismatch!(val) }
         original_target = load_target.dup
 
         if owner.new_record?
@@ -343,7 +366,7 @@ module ActiveRecord
         callback(:before_add, record)
         yield(record) if block_given?
 
-        if association_scope.uniq_value && index = @target.index(record)
+        if association_scope.distinct_value && index = @target.index(record)
           @target[index] = record
         else
           @target << record
@@ -454,7 +477,7 @@ module ActiveRecord
 
         def delete_or_destroy(records, method)
           records = records.flatten
-          records.each { |record| raise_on_type_mismatch(record) }
+          records.each { |record| raise_on_type_mismatch!(record) }
           existing_records = records.reject { |r| r.new_record? }
 
           if existing_records.empty?
@@ -495,9 +518,9 @@ module ActiveRecord
           result = true
 
           records.flatten.each do |record|
-            raise_on_type_mismatch(record)
-            add_to_target(record) do |r|
-              result &&= insert_record(record) unless owner.new_record?
+            raise_on_type_mismatch!(record)
+            add_to_target(record) do |rec|
+              result &&= insert_record(rec) unless owner.new_record?
             end
           end
 
@@ -556,7 +579,8 @@ module ActiveRecord
           end
         end
 
-        # If using a custom finder_sql, #find scans the entire collection.
+        # If using a custom finder_sql or if the :inverse_of option has been
+        # 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