activerecord 3.0.20 → 3.1.0.beta1

data/lib/active_record/associations/has_many_through_association.rb

@@ -1,113 +1,144 @@
-require "active_record/associations/through_association_scope"
 require 'active_support/core_ext/object/blank'
 
 module ActiveRecord
   # = Active Record Has Many Through Association
   module Associations
     class HasManyThroughAssociation < HasManyAssociation #:nodoc:
-      include ThroughAssociationScope
+      include ThroughAssociation
 
       alias_method :new, :build
 
-      def create!(attrs = nil)
-        create_record(attrs, true)
-      end
-
-      def create(attrs = nil)
-        create_record(attrs, false)
-      end
-
-      def destroy(*records)
-        transaction do
-          delete_records(flatten_deeper(records))
-          super
-        end
-      end
-
       # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been
       # loaded and calling collection.size if it has. If it's more likely than not that the collection does
       # have a size larger than zero, and you need to fetch that collection afterwards, it'll take one fewer
       # SELECT query if you use #length.
       def size
-        return @owner.send(:read_attribute, cached_counter_attribute_name) if has_cached_counter?
-        return @target.size if loaded?
-        return count
+        if has_cached_counter?
+          owner.send(:read_attribute, cached_counter_attribute_name)
+        elsif loaded?
+          target.size
+        else
+          count
+        end
       end
 
-      protected
-        def create_record(attrs, force = true)
-          ensure_owner_is_not_new
-
-          transaction do
-            object = @reflection.klass.new(attrs)
-            add_record_to_target_with_callbacks(object) {|r| insert_record(object, force) }
-            object
+      def concat(*records)
+        unless owner.new_record?
+          records.flatten.each do |record|
+            raise_on_type_mismatch(record)
+            record.save! if record.new_record?
           end
         end
 
-        def target_reflection_has_associated_record?
-          if @reflection.through_reflection.macro == :belongs_to && @owner[@reflection.through_reflection.primary_key_name].blank?
-            false
-          else
-            true
+        super
+      end
+
+      def insert_record(record, validate = true)
+        ensure_not_nested
+        return if record.new_record? && !record.save(:validate => validate)
+
+        through_record(record).save!
+        update_counter(1)
+        record
+      end
+
+      private
+
+        def through_record(record)
+          through_association = owner.association(through_reflection.name)
+          attributes = construct_join_attributes(record)
+
+          through_record = Array.wrap(through_association.target).find { |candidate|
+            candidate.attributes.slice(*attributes.keys) == attributes
+          }
+
+          unless through_record
+            through_record = through_association.build(attributes)
+            through_record.send("#{source_reflection.name}=", record)
           end
-        end
 
-        def construct_find_options!(options)
-          options[:joins]   = construct_joins(options[:joins])
-          options[:include] = @reflection.source_reflection.options[:include] if options[:include].nil? && @reflection.source_reflection.options[:include]
+          through_record
         end
 
-        def insert_record(record, force = true, validate = true)
-          if record.new_record?
-            if force
-              record.save!
-            else
-              return false unless record.save(:validate => validate)
+        def build_record(attributes, options = {})
+          ensure_not_nested
+
+          record = super(attributes, options)
+
+          inverse = source_reflection.inverse_of
+          if inverse
+            if inverse.macro == :has_many
+              record.send(inverse.name) << through_record(record)
+            elsif inverse.macro == :has_one
+              record.send("#{inverse.name}=", through_record(record))
             end
           end
 
-          through_association = @owner.send(@reflection.through_reflection.name)
-          through_association.create!(construct_join_attributes(record))
+          record
         end
 
-        # TODO - add dependent option support
-        def delete_records(records)
-          klass = @reflection.through_reflection.klass
-          records.each do |associate|
-            klass.delete_all(construct_join_attributes(associate))
+        def target_reflection_has_associated_record?
+          if through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?
+            false
+          else
+            true
           end
         end
 
-        def find_target
-          return [] unless target_reflection_has_associated_record?
-          with_scope(construct_scope) { @reflection.klass.find(:all) }
+        def update_through_counter?(method)
+          case method
+          when :destroy
+            !inverse_updates_counter_cache?(through_reflection)
+          when :nullify
+            false
+          else
+            true
+          end
         end
 
-        def construct_sql
-          case
-            when @reflection.options[:finder_sql]
-              @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
+        def delete_records(records, method)
+          ensure_not_nested
 
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-              @finder_sql << " AND (#{conditions})" if conditions
-            else
-              @finder_sql = construct_conditions
+          through = owner.association(through_reflection.name)
+          scope   = through.scoped.where(construct_join_attributes(*records))
+
+          case method
+          when :destroy
+            count = scope.destroy_all.length
+          when :nullify
+            count = scope.update_all(source_reflection.foreign_key => nil)
+          else
+            count = scope.delete_all
+          end
+
+          delete_through_records(through, records)
+
+          if through_reflection.macro == :has_many && update_through_counter?(method)
+            update_counter(-count, through_reflection)
           end
 
-          construct_counter_sql
+          update_counter(-count)
         end
 
-        def has_cached_counter?
-          @owner.attribute_present?(cached_counter_attribute_name)
+        def delete_through_records(through, records)
+          if through_reflection.macro == :has_many
+            records.each do |record|
+              through.target.delete(through_record(record))
+            end
+          else
+            records.each do |record|
+              through.target = nil if through.target == through_record(record)
+            end
+          end
         end
 
-        def cached_counter_attribute_name
-          "#{@reflection.name}_count"
+        def find_target
+          return [] unless target_reflection_has_associated_record?
+          scoped.all
         end
 
         # NOTE - not sure that we can actually cope with inverses here
-        def we_can_set_the_inverse_on_this?(record)
+        def invertible_for?(record)
           false
         end
     end

data/lib/active_record/associations/has_one_association.rb

@@ -1,142 +1,72 @@
+require 'active_support/core_ext/object/inclusion'
+
 module ActiveRecord
   # = Active Record Belongs To Has One Association
   module Associations
-    class HasOneAssociation < AssociationProxy #:nodoc:
-      def initialize(owner, reflection)
-        super
-        construct_sql
-      end
+    class HasOneAssociation < SingularAssociation #:nodoc:
+      def replace(record, save = true)
+        raise_on_type_mismatch(record) if record
+        load_target
 
-      def create(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.create_association(attrs)
-        end
-      end
+        reflection.klass.transaction do
+          if target && target != record
+            remove_target!(options[:dependent])
+          end
 
-      def create!(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.create_association!(attrs)
-        end
-      end
+          if record
+            set_inverse_instance(record)
+            set_owner_attributes(record)
 
-      def build(attrs = {}, replace_existing = true)
-        new_record(replace_existing) do |reflection|
-          attrs = merge_with_conditions(attrs)
-          reflection.build_association(attrs)
+            if owner.persisted? && save && !record.save
+              nullify_owner_attributes(record)
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+            end
+          end
         end
-      end
 
-      def replace(obj, dont_save = false)
-        load_target
+        self.target = record
+      end
 
-        unless @target.nil? || @target == obj
-          if dependent? && !dont_save
-            case @reflection.options[:dependent]
+      def delete(method = options[:dependent])
+        if load_target
+          case method
             when :delete
-              @target.delete unless @target.new_record?
-              @owner.clear_association_cache
+              target.delete
             when :destroy
-              @target.destroy unless @target.new_record?
-              @owner.clear_association_cache
+              target.destroy
             when :nullify
-              @target[@reflection.primary_key_name] = nil
-              @target.save unless @owner.new_record? || @target.new_record?
-            end
-          else
-            @target[@reflection.primary_key_name] = nil
-            @target.save unless @owner.new_record? || @target.new_record?
+              target.update_attribute(reflection.foreign_key, nil)
           end
         end
-
-        if obj.nil?
-          @target = nil
-        else
-          raise_on_type_mismatch(obj)
-          set_belongs_to_association_for(obj)
-          @target = (AssociationProxy === obj ? obj.target : obj)
-        end
-
-        set_inverse_instance(obj, @owner)
-        @loaded = true
-
-        unless @owner.new_record? or obj.nil? or dont_save
-          return (obj.save ? self : false)
-        else
-          return (obj.nil? ? nil : self)
-        end
       end
 
-      protected
-        def owner_quoted_id
-          if @reflection.options[:primary_key]
-            @owner.class.quote_value(@owner.send(@reflection.options[:primary_key]))
-          else
-            @owner.quoted_id
-          end
-        end
-
       private
-        def find_target
-          options = @reflection.options.dup
-          (options.keys - [:select, :order, :include, :readonly]).each do |key|
-            options.delete key
-          end
-          options[:conditions] = @finder_sql
-
-          the_target = @reflection.klass.find(:first, options)
-          set_inverse_instance(the_target, @owner)
-          the_target
-        end
-
-        def construct_sql
-          case
-            when @reflection.options[:as]
-              @finder_sql =
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
-                "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-            else
-              @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-          end
-          @finder_sql << " AND (#{conditions})" if conditions
-        end
 
-        def construct_scope
-          create_scoping = {}
-          set_belongs_to_association_for(create_scoping)
-          { :create => create_scoping }
+        # The reason that the save param for replace is false, if for create (not just build),
+        # is because the setting of the foreign keys is actually handled by the scoping when
+        # the record is instantiated, and so they are set straight away and do not need to be
+        # updated within replace.
+        def set_new_record(record)
+          replace(record, false)
         end
 
-        def new_record(replace_existing)
-          # Make sure we load the target first, if we plan on replacing the existing
-          # instance. Otherwise, if the target has not previously been loaded
-          # elsewhere, the instance we create will get orphaned.
-          load_target if replace_existing
-          record = @reflection.klass.send(:with_scope, :create => construct_scope[:create]) do
-            yield @reflection
-          end
-
-          if replace_existing
-            replace(record, true)
+        def remove_target!(method)
+          if method.in?([:delete, :destroy])
+            target.send(method)
           else
-            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
-            self.target = record
-            set_inverse_instance(record, @owner)
-          end
+            nullify_owner_attributes(target)
 
-          record
-        end
-
-        def we_can_set_the_inverse_on_this?(record)
-          inverse = @reflection.inverse_of
-          return !inverse.nil?
+            if target.persisted? && owner.persisted? && !target.save
+              set_owner_attributes(target)
+              raise RecordNotSaved, "Failed to remove the existing associated #{reflection.name}. " +
+                                    "The record failed to save when after its foreign key was set to nil."
+            end
+          end
         end
 
-        def merge_with_conditions(attrs={})
-          attrs ||= {}
-          attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
-          attrs
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
         end
     end
   end

data/lib/active_record/associations/has_one_through_association.rb

@@ -1,40 +1,36 @@
-require "active_record/associations/through_association_scope"
-
 module ActiveRecord
   # = Active Record Has One Through Association
   module Associations
-    class HasOneThroughAssociation < HasOneAssociation
-      include ThroughAssociationScope
+    class HasOneThroughAssociation < HasOneAssociation #:nodoc:
+      include ThroughAssociation
 
-      def replace(new_value)
-        create_through_record(new_value)
-        @target = new_value
+      def replace(record)
+        create_through_record(record)
+        self.target = record
       end
 
       private
 
-      def create_through_record(new_value) #nodoc:
-        klass = @reflection.through_reflection.klass
+        def create_through_record(record)
+          ensure_not_nested
+
+          through_proxy  = owner.association(through_reflection.name)
+          through_record = through_proxy.send(:load_target)
 
-        current_object = @owner.send(@reflection.through_reflection.name)
+          if through_record && !record
+            through_record.destroy
+          elsif record
+            attributes = construct_join_attributes(record)
 
-        if current_object
-           new_value ? current_object.update_attributes(construct_join_attributes(new_value)) : current_object.destroy
-        elsif new_value
-          if @owner.new_record?
-            self.target = new_value
-            through_association = @owner.send(:association_instance_get, @reflection.through_reflection.name)
-            through_association.build(construct_join_attributes(new_value))
-          else
-            @owner.send(@reflection.through_reflection.name, klass.create(construct_join_attributes(new_value)))
+            if through_record
+              through_record.update_attributes(attributes)
+            elsif owner.new_record?
+              through_proxy.build(attributes)
+            else
+              through_proxy.create(attributes)
+            end
           end
         end
-      end
-
-    private
-      def find_target
-        with_scope(construct_scope) { @reflection.klass.find(:first) }
-      end
     end
   end
 end