activerecord 3.1.0.rc4 → 3.1.0.rc5

data/CHANGELOG

@@ -1,5 +1,30 @@
 *Rails 3.1.0 (unreleased)*
 
+* Active Record's dynamic finder will now show a deprecation warning if you passing in less number of arguments than what you call in method signature. This behavior will raise ArgumentError in the next version of Rails [Prem Sichanugrist]
+
+* Deprecated the AssociationCollection constant. CollectionProxy is now the appropriate constant
+  to use, though be warned that this is not really a public API.
+
+  This should solve upgrade problems with the will_paginate plugin (and perhaps others). Thanks
+  Paul Battley for reporting.
+
+  [Jon Leighton]
+
+* ActiveRecord::MacroReflection::AssociationReflection#build_record has a new method signature.
+
+  Before: def build_association(*options)
+  After:  def build_association(*options, &block)
+
+  Users who are redefining this method to extend functionality should ensure that the block is
+  passed through to ActiveRecord::Base#new.
+
+  This change is necessary to fix https://github.com/rails/rails/issues/1842.
+
+  A deprecation warning and workaround has been added to 3.1, but authors will need to update
+  their code for it to work correctly in 3.2.
+
+  [Jon Leighton]
+
 * AR#pluralize_table_names can be used to singularize/pluralize table name of an individual model:
 
     class User < ActiveRecord::Base

data/lib/active_record/associations.rb

@@ -119,6 +119,7 @@ module ActiveRecord
     autoload :SingularAssociation,   'active_record/associations/singular_association'
     autoload :CollectionAssociation, 'active_record/associations/collection_association'
     autoload :CollectionProxy,       'active_record/associations/collection_proxy'
+    autoload :AssociationCollection, 'active_record/associations/collection_proxy'
 
     autoload :BelongsToAssociation,            'active_record/associations/belongs_to_association'
     autoload :BelongsToPolymorphicAssociation, 'active_record/associations/belongs_to_polymorphic_association'
@@ -426,7 +427,7 @@ module ActiveRecord
     #     end
     #   end
     #
-    #   person = Account.find(:first).people.find_or_create_by_name("David Heinemeier Hansson")
+    #   person = Account.first.people.find_or_create_by_name("David Heinemeier Hansson")
     #   person.first_name # => "David"
     #   person.last_name  # => "Heinemeier Hansson"
     #
@@ -483,7 +484,7 @@ module ActiveRecord
     #     belongs_to :book
     #   end
     #
-    #   @author = Author.find :first
+    #   @author = Author.first
     #   @author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to
     #   @author.books                              # selects all books by using the Authorship join model
     #
@@ -503,7 +504,7 @@ module ActiveRecord
     #     belongs_to :client
     #   end
     #
-    #   @firm = Firm.find :first
+    #   @firm = Firm.first
     #   @firm.clients.collect { |c| c.invoices }.flatten # select all invoices for all clients of the firm
     #   @firm.invoices                                   # selects all invoices by going through the Client join model
     #
@@ -738,7 +739,7 @@ module ActiveRecord
     #     has_many :most_recent_comments, :class_name => 'Comment', :order => 'id DESC', :limit => 10
     #   end
     #
-    #   Picture.find(:first, :include => :most_recent_comments).most_recent_comments # => returns all associated comments.
+    #   Picture.first(:include => :most_recent_comments).most_recent_comments # => returns all associated comments.
     #
     # When eager loaded, conditions are interpolated in the context of the model class, not
     # the model instance.  Conditions are lazily interpolated before the actual model exists.
@@ -1200,7 +1201,7 @@ module ActiveRecord
       # === Example
       #
       # An Account class declares <tt>has_one :beneficiary</tt>, which will add:
-      # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.find(:first, :conditions => "account_id = #{id}")</tt>)
+      # * <tt>Account#beneficiary</tt> (similar to <tt>Beneficiary.first(:conditions => "account_id = #{id}")</tt>)
       # * <tt>Account#beneficiary=(beneficiary)</tt> (similar to <tt>beneficiary.account_id = account.id; beneficiary.save</tt>)
       # * <tt>Account#build_beneficiary</tt> (similar to <tt>Beneficiary.new("account_id" => id)</tt>)
       # * <tt>Account#create_beneficiary</tt> (similar to <tt>b = Beneficiary.new("account_id" => id); b.save; b</tt>)

data/lib/active_record/associations/alias_tracker.rb

@@ -9,7 +9,7 @@ module ActiveRecord
 
       # table_joins is an array of arel joins which might conflict with the aliases we assign here
       def initialize(table_joins = [])
-        @aliases     = Hash.new
+        @aliases     = Hash.new { |h,k| h[k] = initial_count_for(k) }
         @table_joins = table_joins
       end
 
@@ -26,8 +26,6 @@ module ActiveRecord
       def aliased_name_for(table_name, aliased_name = nil)
         aliased_name ||= table_name
 
-        initialize_count_for(table_name) if aliases[table_name].nil?
-
         if aliases[table_name].zero?
           # If it's zero, we can have our table_name
           aliases[table_name] = 1
@@ -36,8 +34,6 @@ module ActiveRecord
           # Otherwise, we need to use an alias
           aliased_name = connection.table_alias_for(aliased_name)
 
-          initialize_count_for(aliased_name) if aliases[aliased_name].nil?
-
           # Update the count
           aliases[aliased_name] += 1
 
@@ -49,32 +45,24 @@ module ActiveRecord
         end
       end
 
-      def pluralize(table_name, base)
-        base.pluralize_table_names ? table_name.to_s.pluralize : table_name.to_s
-      end
-
       private
 
-        def initialize_count_for(name)
-          aliases[name] = 0
-
-          unless Arel::Table === table_joins
-            # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
-            quoted_name = connection.quote_table_name(name).downcase
+        def initial_count_for(name)
+          return 0 if Arel::Table === table_joins
 
-            aliases[name] += table_joins.map { |join|
-              # Table names + table aliases
-              join.left.downcase.scan(
-                /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
-              ).size
-            }.sum
-          end
+          # quoted_name should be downcased as some database adapters (Oracle) return quoted name in uppercase
+          quoted_name = connection.quote_table_name(name).downcase
 
-          aliases[name]
+          table_joins.map { |join|
+            # Table names + table aliases
+            join.left.downcase.scan(
+              /join(?:\s+\w+)?\s+(\S+\s+)?#{quoted_name}\son/
+            ).size
+          }.sum
         end
 
         def truncate(name)
-          name[0..connection.table_alias_length-3]
+          name.slice(0, connection.table_alias_length - 2)
         end
 
         def connection

data/lib/active_record/associations/association.rb

@@ -1,5 +1,6 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/inclusion'
+require 'active_support/deprecation'
 
 module ActiveRecord
   module Associations
@@ -30,7 +31,7 @@ module ActiveRecord
         @updated = false
 
         reset
-        construct_scope
+        reset_scope
       end
 
       # Returns the name of the table of the related class:
@@ -51,7 +52,7 @@ module ActiveRecord
       # Reloads the \target and returns +self+ on success.
       def reload
         reset
-        construct_scope
+        reset_scope
         load_target
         self unless target.nil?
       end
@@ -84,21 +85,25 @@ module ActiveRecord
       end
 
       def scoped
-        target_scope.merge(@association_scope)
+        target_scope.merge(association_scope)
       end
 
-      # Construct the scope for this association.
+      # 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
       # by scope.scoping { ... } or with_scope { ... } etc, which affects the scope which
       # actually gets built.
-      def construct_scope
+      def association_scope
         if klass
-          @association_scope = AssociationScope.new(self).scope
+          @association_scope ||= AssociationScope.new(self).scope
         end
       end
 
+      def reset_scope
+        @association_scope = nil
+      end
+
       # Set the inverse association, if possible
       def set_inverse_instance(record)
         if record && invertible_for?(record)
@@ -224,6 +229,51 @@ module ActiveRecord
         def association_class
           @reflection.klass
         end
+
+        def build_record(attributes, options)
+          reflection.original_build_association_called = false
+
+          record = reflection.build_association(attributes, options) do |r|
+            r.assign_attributes(
+              create_scope.except(*r.changed),
+              :without_protection => true
+            )
+          end
+
+          if !reflection.original_build_association_called &&
+             (record.changed & create_scope.keys) != create_scope.keys
+            # We have detected that there is an overridden AssociationReflection#build_association
+            # method, but it looks like it has not passed through the block above. So try again and
+            # show a noisy deprecation warning.
+
+            record.assign_attributes(
+              create_scope.except(*record.changed),
+              :without_protection => true
+            )
+
+            method = reflection.method(:build_association)
+            if RUBY_VERSION >= '1.9.2'
+              source = method.source_location
+              debug_info = "It looks like the method is defined in #{source[0]} at line #{source[1]}."
+            else
+              debug_info = "This might help you find the method: #{method}. If you run this on Ruby 1.9.2 we can tell you exactly where the method is."
+            end
+
+            ActiveSupport::Deprecation.warn <<-WARN
+It looks like ActiveRecord::Reflection::AssociationReflection#build_association has been redefined, either by you or by a plugin or library that you are using. The signature of this method has changed.
+
+  Before: def build_association(*options)
+  After:  def build_association(*options, &block)
+
+The block argument now needs to be passed through to ActiveRecord::Base#new when this method is overridden, or else your associations will not function correctly in Rails 3.2.
+
+#{debug_info}
+
+            WARN
+          end
+
+          record
+        end
     end
   end
 end

data/lib/active_record/associations/belongs_to_association.rb

@@ -37,7 +37,7 @@ module ActiveRecord
         # Checks whether record is different to the current target, without loading it
         def different_target?(record)
           record.nil? && owner[reflection.foreign_key] ||
-          record.id   != owner[reflection.foreign_key]
+          record && record.id != owner[reflection.foreign_key]
         end
 
         def replace_keys(record)

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

@@ -7,24 +7,22 @@ module ActiveRecord::Associations::Builder
     def build
       reflection = super
       check_validity(reflection)
-      define_after_destroy_method
+      define_destroy_hook
       reflection
     end
 
     private
 
-      def define_after_destroy_method
+      def define_destroy_hook
         name = self.name
-        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-          def #{after_destroy_method_name}
-            association(#{name.to_sym.inspect}).delete_all
-          end
-        eoruby
-        model.after_destroy after_destroy_method_name
-      end
-
-      def after_destroy_method_name
-        "has_and_belongs_to_many_after_destroy_for_#{name}"
+        model.send(:include, Module.new {
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def destroy_associations
+              association(#{name.to_sym.inspect}).delete_all
+              super
+            end
+          RUBY
+        })
       end
 
       # TODO: These checks should probably be moved into the Reflection, and we should not be

data/lib/active_record/associations/collection_association.rb

@@ -114,19 +114,13 @@ module ActiveRecord
       # Add +records+ to this association.  Returns +self+ so method calls may be chained.
       # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
       def concat(*records)
-        result = true
         load_target if owner.new_record?
 
-        transaction do
-          records.flatten.each do |record|
-            raise_on_type_mismatch(record)
-            add_to_target(record) do |r|
-              result &&= insert_record(record) unless owner.new_record?
-            end
-          end
+        if owner.new_record?
+          concat_records(records)
+        else
+          transaction { concat_records(records) }
         end
-
-        result && records
       end
 
       # Starts a transaction in the association class's database connection.
@@ -295,14 +289,10 @@ module ActiveRecord
         other_array.each { |val| raise_on_type_mismatch(val) }
         original_target = load_target.dup
 
-        transaction do
-          delete(target - other_array)
-
-          unless concat(other_array - target)
-            @target = original_target
-            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
-                                  "new records could not be saved."
-          end
+        if owner.new_record?
+          replace_records(other_array, original_target)
+        else
+          transaction { replace_records(other_array, original_target) }
         end
       end
 
@@ -388,7 +378,7 @@ module ActiveRecord
 
           persisted.map! do |record|
             # Unfortunately we cannot simply do memory.delete(record) since on 1.8 this returns
-            # record rather than memory.at(memory.index(record)). The behaviour is fixed in 1.9.
+            # record rather than memory.at(memory.index(record)). The behavior is fixed in 1.9.
             mem_index = memory.index(record)
 
             if mem_index
@@ -433,25 +423,25 @@ module ActiveRecord
           scoped.scope_for_create.stringify_keys
         end
 
-        def build_record(attributes, options)
-          record = reflection.build_association(attributes, options)
-          record.assign_attributes(create_scope.except(*record.changed), :without_protection => true)
-          record
-        end
-
         def delete_or_destroy(records, method)
           records = records.flatten
           records.each { |record| raise_on_type_mismatch(record) }
           existing_records = records.reject { |r| r.new_record? }
 
-          transaction do
-            records.each { |record| callback(:before_remove, record) }
+          if existing_records.empty?
+            remove_records(existing_records, records, method)
+          else
+            transaction { remove_records(existing_records, records, method) }
+          end
+        end
+
+        def remove_records(existing_records, records, method)
+          records.each { |record| callback(:before_remove, record) }
 
-            delete_records(existing_records, method) if existing_records.any?
-            records.each { |record| target.delete(record) }
+          delete_records(existing_records, method) if existing_records.any?
+          records.each { |record| target.delete(record) }
 
-            records.each { |record| callback(:after_remove, record) }
-          end
+          records.each { |record| callback(:after_remove, record) }
         end
 
         # Delete the given records from the association, using one of the methods :destroy,
@@ -460,6 +450,29 @@ module ActiveRecord
           raise NotImplementedError
         end
 
+        def replace_records(new_target, original_target)
+          delete(target - new_target)
+
+          unless concat(new_target - target)
+            @target = original_target
+            raise RecordNotSaved, "Failed to replace #{reflection.name} because one or more of the " \
+                                  "new records could not be saved."
+          end
+        end
+
+        def concat_records(records)
+          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?
+            end
+          end
+
+          result && records
+        end
+
         def callback(method, record)
           callbacks_for(method).each do |callback|
             case callback

data/lib/active_record/associations/collection_proxy.rb

@@ -1,5 +1,12 @@
+require 'active_support/deprecation'
+
 module ActiveRecord
   module Associations
+    AssociationCollection = ActiveSupport::Deprecation::DeprecatedConstantProxy.new(
+      'ActiveRecord::Associations::AssociationCollection',
+      'ActiveRecord::Associations::CollectionProxy'
+    )
+
     # Association proxies in Active Record are middlemen between the object that
     # holds the association, known as the <tt>@owner</tt>, and the actual associated
     # object, known as the <tt>@target</tt>. The kind of association any proxy is
@@ -12,7 +19,7 @@ module ActiveRecord
     #     has_many :posts
     #   end
     #
-    #   blog = Blog.find(:first)
+    #   blog = Blog.first
     #
     # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
     # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
@@ -58,10 +65,10 @@ module ActiveRecord
 
       alias_method :new, :build
 
-      def respond_to?(*args)
+      def respond_to?(name, include_private = false)
         super ||
-        (load_target && target.respond_to?(*args)) ||
-        @association.klass.respond_to?(*args)
+        (load_target && target.respond_to?(name, include_private)) ||
+        @association.klass.respond_to?(name, include_private)
       end
 
       def method_missing(method, *args, &block)