activerecord 3.1.12 → 3.2.0.rc1

data/lib/active_record/associations/association.rb

@@ -1,6 +1,5 @@
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/object/inclusion'
-require 'active_support/deprecation'
 
 module ActiveRecord
   module Associations
@@ -231,48 +230,14 @@ module ActiveRecord
         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.
+          attributes = (attributes || {}).reverse_merge(creation_attributes)
 
+          reflection.build_association(attributes, options) do |record|
             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

data/lib/active_record/associations/association_scope.rb

@@ -20,31 +20,19 @@ module ActiveRecord
         # It's okay to just apply all these like this. The options will only be present if the
         # association supports that option; this is enforced by the association builder.
         scope = scope.apply_finder_options(options.slice(
-          :readonly, :include, :order, :limit, :joins, :group, :having, :offset))
+          :readonly, :include, :order, :limit, :joins, :group, :having, :offset, :select))
 
         if options[:through] && !options[:include]
           scope = scope.includes(source_options[:include])
         end
 
-        if select = select_value
-          scope = scope.select(select)
-        end
+        scope = scope.uniq if options[:uniq]
 
         add_constraints(scope)
       end
 
       private
 
-      def select_value
-        select_value = options[:select]
-
-        if reflection.collection?
-          select_value ||= options[:uniq] && "DISTINCT #{reflection.quoted_table_name}.*"
-        end
-
-        select_value
-      end
-
       def add_constraints(scope)
         tables = construct_tables
 
@@ -87,7 +75,7 @@ module ActiveRecord
 
             conditions.each do |condition|
               if options[:through] && condition.is_a?(Hash)
-                condition = disambiguate_condition(table, condition)
+                condition = { table.name => condition }
               end
 
               scope = scope.where(interpolate(condition))
@@ -126,21 +114,6 @@ module ActiveRecord
         end
       end
 
-      def disambiguate_condition(table, condition)
-        if condition.is_a?(Hash)
-          Hash[
-            condition.map do |k, v|
-              if v.is_a?(Hash)
-                [k, v]
-              else
-                [table.table_alias || table.name, { k => v }]
-              end
-            end
-          ]
-        else
-          condition
-        end
-      end
     end
   end
 end

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

@@ -16,6 +16,10 @@ module ActiveRecord::Associations::Builder
       @model, @name, @options = model, name, options
     end
 
+    def mixin
+      @model.generated_feature_methods
+    end
+
     def build
       validate_options
       reflection = model.create_reflection(self.class.macro, name, options, model)
@@ -36,16 +40,14 @@ module ActiveRecord::Associations::Builder
 
       def define_readers
         name = self.name
-
-        model.redefine_method(name) do |*params|
+        mixin.redefine_method(name) do |*params|
           association(name).reader(*params)
         end
       end
 
       def define_writers
         name = self.name
-
-        model.redefine_method("#{name}=") do |value|
+        mixin.redefine_method("#{name}=") do |value|
           association(name).writer(value)
         end
       end

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

@@ -25,14 +25,14 @@ module ActiveRecord::Associations::Builder
         name         = self.name
 
         method_name = "belongs_to_counter_cache_after_create_for_#{name}"
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
           record.class.increment_counter(cache_column, record.id) unless record.nil?
         end
         model.after_create(method_name)
 
         method_name = "belongs_to_counter_cache_before_destroy_for_#{name}"
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
           record.class.decrement_counter(cache_column, record.id) unless record.nil?
         end
@@ -48,7 +48,7 @@ module ActiveRecord::Associations::Builder
         method_name = "belongs_to_touch_after_save_or_destroy_for_#{name}"
         touch       = options[:touch]
 
-        model.redefine_method(method_name) do
+        mixin.redefine_method(method_name) do
           record = send(name)
 
           unless record.nil?

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

@@ -58,7 +58,7 @@ module ActiveRecord::Associations::Builder
         super
 
         name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids") do
+        mixin.redefine_method("#{name.to_s.singularize}_ids") do
           association(name).ids_reader
         end
       end
@@ -67,7 +67,7 @@ module ActiveRecord::Associations::Builder
         super
 
         name = self.name
-        model.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
+        mixin.redefine_method("#{name.to_s.singularize}_ids=") do |ids|
           association(name).ids_writer(ids)
         end
       end

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

@@ -28,7 +28,7 @@ module ActiveRecord::Associations::Builder
 
       def define_destroy_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           send(name).each do |o|
             # No point in executing the counter update since we're going to destroy the parent anyway
             counter_method = ('belongs_to_counter_cache_before_destroy_for_' + self.class.name.downcase).to_sym
@@ -45,21 +45,21 @@ module ActiveRecord::Associations::Builder
 
       def define_delete_all_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           association(name).delete_all_on_destroy
         end
       end
 
       def define_nullify_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           send(name).delete_all
         end
       end
 
       def define_restrict_dependency_method
         name = self.name
-        model.send(:define_method, dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).empty?
         end
       end

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

@@ -44,18 +44,17 @@ module ActiveRecord::Associations::Builder
       end
 
       def define_destroy_dependency_method
-        model.send(:class_eval, <<-eoruby, __FILE__, __LINE__ + 1)
-          def #{dependency_method_name}
-            association(#{name.to_sym.inspect}).delete
-          end
-        eoruby
+        name = self.name
+        mixin.redefine_method(dependency_method_name) do
+          association(name).delete
+        end
       end
       alias :define_delete_dependency_method :define_destroy_dependency_method
       alias :define_nullify_dependency_method :define_destroy_dependency_method
 
       def define_restrict_dependency_method
         name = self.name
-        model.redefine_method(dependency_method_name) do
+        mixin.redefine_method(dependency_method_name) do
           raise ActiveRecord::DeleteRestrictionError.new(name) unless send(name).nil?
         end
       end

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

@@ -13,31 +13,18 @@ module ActiveRecord::Associations::Builder
 
     private
 
-      def define_readers
-        super
-        name = self.name
-
-        model.redefine_method("#{name}_loaded?") do
-          ActiveSupport::Deprecation.warn(
-            "Calling obj.#{name}_loaded? is deprecated. Please use " \
-            "obj.association(:#{name}).loaded? instead."
-          )
-          association(name).loaded?
-        end
-      end
-
       def define_constructors
         name = self.name
 
-        model.redefine_method("build_#{name}") do |*params, &block|
+        mixin.redefine_method("build_#{name}") do |*params, &block|
           association(name).build(*params, &block)
         end
 
-        model.redefine_method("create_#{name}") do |*params, &block|
+        mixin.redefine_method("create_#{name}") do |*params, &block|
           association(name).create(*params, &block)
         end
 
-        model.redefine_method("create_#{name}!") do |*params, &block|
+        mixin.redefine_method("create_#{name}!") do |*params, &block|
           association(name).create!(*params, &block)
         end
       end

data/lib/active_record/associations/collection_association.rb

@@ -49,10 +49,18 @@ module ActiveRecord
           end
         else
           column  = "#{reflection.quoted_table_name}.#{reflection.association_primary_key}"
+          relation = scoped
 
-          scoped.select(column).except(:includes).map! do |record|
-            record.send(reflection.association_primary_key)
+          including = (relation.eager_load_values + relation.includes_values).uniq
+
+          if including.any?
+            join_dependency = ActiveRecord::Associations::JoinDependency.new(reflection.klass, including, [])
+            relation = join_dependency.join_associations.inject(relation) do |r, association|
+              association.join_relation(r)
+            end
           end
+
+          relation.uniq.pluck(column)
         end
       end
 
@@ -115,22 +123,16 @@ module ActiveRecord
         create_record(attributes, options, true, &block)
       end
 
-      # Add +records+ to this association.  Returns +self+ so method calls may be chained.
+      # 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.
@@ -248,7 +250,7 @@ module ActiveRecord
       # This method is abstract in the sense that it relies on
       # +count_records+, which is a method descendants have to provide.
       def size
-        if owner.new_record? || (loaded? && !options[:uniq])
+        if !find_target? || (loaded? && !options[:uniq])
           target.size
         elsif !loaded? && options[:group]
           load_target.size
@@ -306,14 +308,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
 
@@ -453,14 +451,20 @@ module ActiveRecord
           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,
@@ -469,6 +473,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,12 +1,5 @@
-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
@@ -46,7 +39,7 @@ module ActiveRecord
       instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|^respond_to|proxy_/ }
 
       delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from,
-               :lock, :readonly, :having, :to => :scoped
+               :lock, :readonly, :having, :pluck, :to => :scoped
 
       delegate :target, :load_target, :loaded?, :to => :@association
 
@@ -134,33 +127,6 @@ module ActiveRecord
         proxy_association.reload
         self
       end
-
-      def proxy_owner
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_owner is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).owner instead. Or, from an " \
-          "association extension you can access proxy_association.owner."
-        )
-        proxy_association.owner
-      end
-
-      def proxy_target
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_target is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).target instead. Or, from an " \
-          "association extension you can access proxy_association.target."
-        )
-        proxy_association.target
-      end
-
-      def proxy_reflection
-        ActiveSupport::Deprecation.warn(
-          "Calling record.#{@association.reflection.name}.proxy_reflection is deprecated. Please use " \
-          "record.association(:#{@association.reflection.name}).reflection instead. Or, from an " \
-          "association extension you can access proxy_association.reflection."
-        )
-        proxy_association.reflection
-      end
     end
   end
 end