activerecord 1.0.0 → 4.0.0

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,46 +1,65 @@
 module ActiveRecord
+  # = Active Record Has And Belongs To Many Association
   module Associations
-    class HasAndBelongsToManyCollection < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, join_table, options)
-        super(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        
-        @association_foreign_key = options[:association_foreign_key] || association_class_name.downcase + "_id"
-        association_table_name = options[:table_name] || @association_class.table_name(association_class_name)
-        @join_table = join_table
-        @order = options[:order] || "t.#{@owner.class.primary_key}"
-
-        @finder_sql = options[:finder_sql] ||
-              "SELECT t.* FROM #{association_table_name} t, #{@join_table} j " +
-              "WHERE t.#{@owner.class.primary_key} = j.#{@association_foreign_key} AND " +
-              "j.#{association_class_primary_key_name} = '#{@owner.id}' ORDER BY #{@order}"
-      end
-        
-      def <<(record)
-        raise ActiveRecord::AssociationTypeMismatch unless @association_class === record
-        sql = @options[:insert_sql] || 
-            "INSERT INTO #{@join_table} (#{@association_class_primary_key_name}, #{@association_foreign_key}) " +
-            "VALUES ('#{@owner.id}', '#{record.id}')"
-        @owner.connection.execute(sql)
-        @collection_array << record unless @collection_array.nil?
-      end
-        
-      def delete(records)
-        records = duplicated_records_array(records)
-        sql = @options[:delete_sql] || "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = '#{@owner.id}'"
-        ids = records.map { |record| "'" + record.id.to_s + "'" }.join(',')
-        @owner.connection.delete "#{sql} AND #{@association_foreign_key} in (#{ids})"
-        records.each {|record| @collection_array.delete(record) } unless @collection_array.nil?
+    class HasAndBelongsToManyAssociation < CollectionAssociation #:nodoc:
+      attr_reader :join_table
+
+      def initialize(owner, reflection)
+        @join_table = Arel::Table.new(reflection.join_table)
+        super
       end
-        
-      protected
-        def find_all_records
-          @association_class.find_by_sql(@finder_sql)
+
+      def insert_record(record, validate = true, raise = false)
+        if record.new_record?
+          if raise
+            record.save!(:validate => validate)
+          else
+            return unless record.save(:validate => validate)
+          end
         end
-            
-        def count_records
-          load_collection_to_array
-          @collection_array.size
+
+        if options[:insert_sql]
+          owner.connection.insert(interpolate(options[:insert_sql], record))
+        else
+          stmt = join_table.compile_insert(
+            join_table[reflection.foreign_key]             => owner.id,
+            join_table[reflection.association_foreign_key] => record.id
+          )
+
+          owner.class.connection.insert stmt
         end
+
+        record
       end
+
+      private
+
+        def count_records
+          load_target.size
+        end
+
+        def delete_records(records, method)
+          if sql = options[:delete_sql]
+            records = load_target if records == :all
+            records.each { |record| owner.class.connection.delete(interpolate(sql, record)) }
+          else
+            relation  = join_table
+            condition = relation[reflection.foreign_key].eq(owner.id)
+
+            unless records == :all
+              condition = condition.and(
+                relation[reflection.association_foreign_key]
+                  .in(records.map { |x| x.id }.compact)
+              )
+            end
+
+            owner.class.connection.delete(relation.where(condition).compile_delete)
+          end
+        end
+
+        def invertible_for?(record)
+          false
+        end
+    end
   end
-end
+end

data/lib/active_record/associations/has_many_association.rb

@@ -1,104 +1,135 @@
 module ActiveRecord
+  # = Active Record Has Many Association
   module Associations
-    class HasManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        super(owner, association_name, association_class_name, association_class_primary_key_name, options)
-        @conditions = options[:conditions]
-        
-        if options[:finder_sql]
-          @counter_sql = options[:finder_sql].gsub(/SELECT (.*) FROM/, "SELECT COUNT(*) FROM")
-          @finder_sql = options[:finder_sql]
-        else
-          @counter_sql = "#{@association_class_primary_key_name} = '#{@owner.id}'#{@conditions ? " AND " + @conditions : ""}"
-          @finder_sql = "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"   
-        end
-      end
-      
-      def <<(record)
-        raise ActiveRecord::AssociationTypeMismatch unless @association_class === record
-        record.send(@association_class_primary_key_name + "=", @owner.id)
-        record.save(false)
-        @collection_array << record unless @collection_array.nil?
-      end
- 
-      def delete(records)
-        duplicated_records_array(records).each do |record|
-          next if record.send(@association_class_primary_key_name) != @owner.id
-          record.send(@association_class_primary_key_name + "=", nil)
-          record.save(false)
-          @collection_array.delete(record) unless @collection_array.nil?
-        end
-      end
-      
-      def create(attributes = {})
-        # We can't use the regular Base.create method as the foreign key might be a protected attribute, hence the repetion
-        record = @association_class.new(attributes || {})
-        record.send(@association_class_primary_key_name + "=", @owner.id)
-        record.save
-
-        @collection_array << record unless @collection_array.nil?
-        
-        return record
-      end
+    # This is the proxy that handles a has many association.
+    #
+    # If the association has a <tt>:through</tt> option further specialization
+    # is provided by its child HasManyThroughAssociation.
+    class HasManyAssociation < CollectionAssociation #:nodoc:
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) unless empty?
+
+        when :restrict_with_error
+          unless empty?
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.many", record: record)
+            false
+          end
 
-      def build(attributes = {})
-        association = @association_class.new
-        association.attributes = attributes.merge({ "#{@association_class_primary_key_name}" => @owner.id})
-        association
-      end
-      
-      def find_all(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil, &block)
-        if block_given? || @options[:finder_sql]
-          load_collection_to_array
-          @collection_array.send(:find_all, &block)
         else
-          @association_class.find_all(
-              "#{@association_class_primary_key_name} = '#{@owner.id}' " +
-              "#{@conditions ? " AND " + @conditions : ""} #{runtime_conditions ? " AND " + runtime_conditions : ""}",
-              orderings, 
-              limit, 
-              joins
-            )
+          if options[:dependent] == :destroy
+            # No point in executing the counter update since we're going to destroy the parent anyway
+            load_target.each { |t| t.destroyed_by_association = reflection }
+            destroy_all
+          else
+            delete_all
+          end
         end
       end
 
-      def find(association_id = nil, &block)
-        if block_given? || @options[:finder_sql]
-          load_collection_to_array
-          return @collection_array.send(:find, &block)
+      def insert_record(record, validate = true, raise = false)
+        set_owner_attributes(record)
+
+        if raise
+          record.save!(:validate => validate)
         else
-          @association_class.find_on_conditions(
-              association_id, "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"
-            )
+          record.save(:validate => validate)
         end
       end
-      
-      protected
-        def find_all_records
-          if @options[:finder_sql]
-            @association_class.find_by_sql(@finder_sql)
+
+      private
+
+        # Returns the number of records in this collection.
+        #
+        # If the association has a counter cache it gets that value. Otherwise
+        # it will attempt to do a count via SQL, bounded to <tt>:limit</tt> if
+        # there's one. Some configuration options like :group make it impossible
+        # to do an SQL count, in those cases the array count will be used.
+        #
+        # That does not depend on whether the collection has already been loaded
+        # or not. The +size+ method is the one that takes the loaded flag into
+        # account and delegates to +count_records+ if needed.
+        #
+        # If the collection is empty the target is set to an empty array and
+        # the loaded flag is set to true as well.
+        def count_records
+          count = if has_cached_counter?
+            owner.send(:read_attribute, cached_counter_attribute_name)
+          elsif options[:counter_sql] || options[:finder_sql]
+            reflection.klass.count_by_sql(custom_counter_sql)
           else
-            @association_class.find_all(@finder_sql, @options[:order] ? @options[:order] : nil)
+            scope.count
           end
+
+          # If there's nothing in the database and @target has no new records
+          # we are certain the current target is an empty array. This is a
+          # documented side-effect of the method that may avoid an extra SELECT.
+          @target ||= [] and loaded! if count == 0
+
+          [association_scope.limit_value, count].compact.min
         end
-        
-        def count_records
-          if has_cached_counter?
-            @owner.send(:read_attribute, cached_counter_attribute_name)
-          elsif @options[:finder_sql]
-            @association_class.count_by_sql(@counter_sql)
-          else
-            @association_class.count(@counter_sql)
+
+        def has_cached_counter?(reflection = reflection)
+          owner.attribute_present?(cached_counter_attribute_name(reflection))
+        end
+
+        def cached_counter_attribute_name(reflection = reflection)
+          options[:counter_cache] || "#{reflection.name}_count"
+        end
+
+        def update_counter(difference, reflection = reflection)
+          if has_cached_counter?(reflection)
+            counter = cached_counter_attribute_name(reflection)
+            owner.class.update_counters(owner.id, counter => difference)
+            owner[counter] += difference
+            owner.changed_attributes.delete(counter) # eww
           end
         end
-        
-        def has_cached_counter?
-          @owner.attribute_present?(cached_counter_attribute_name)
+
+        # This shit is nasty. We need to avoid the following situation:
+        #
+        #   * An associated record is deleted via record.destroy
+        #   * Hence the callbacks run, and they find a belongs_to on the record with a
+        #     :counter_cache options which points back at our owner. So they update the
+        #     counter cache.
+        #   * In which case, we must make sure to *not* update the counter cache, or else
+        #     it will be decremented twice.
+        #
+        # Hence this method.
+        def inverse_updates_counter_cache?(reflection = reflection)
+          counter_name = cached_counter_attribute_name(reflection)
+          reflection.klass.reflect_on_all_associations(:belongs_to).any? { |inverse_reflection|
+            inverse_reflection.counter_cache_column == counter_name
+          }
+        end
+
+        # Deletes the records according to the <tt>:dependent</tt> option.
+        def delete_records(records, method)
+          if method == :destroy
+            records.each { |r| r.destroy }
+            update_counter(-records.length) unless inverse_updates_counter_cache?
+          else
+            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)
+            end
+
+            if method == :delete_all
+              update_counter(-scope.delete_all)
+            else
+              update_counter(-scope.update_all(reflection.foreign_key => nil))
+            end
+          end
         end
-        
-        def cached_counter_attribute_name
-          @association_name + "_count"
+
+        def foreign_key_present?
+          owner.attribute_present?(reflection.association_primary_key)
         end
     end
   end
-end
+end

data/lib/active_record/associations/has_many_through_association.rb

@@ -0,0 +1,197 @@
+
+module ActiveRecord
+  # = Active Record Has Many Through Association
+  module Associations
+    class HasManyThroughAssociation < HasManyAssociation #:nodoc:
+      include ThroughAssociation
+
+      def initialize(owner, reflection)
+        super
+
+        @through_records     = {}
+        @through_association = nil
+      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
+        if has_cached_counter?
+          owner.send(:read_attribute, cached_counter_attribute_name)
+        elsif loaded?
+          target.size
+        else
+          count
+        end
+      end
+
+      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
+
+        super
+      end
+
+      def concat_records(records)
+        ensure_not_nested
+
+        records = super
+
+        if owner.new_record? && records
+          records.flatten.each do |record|
+            build_through_record(record)
+          end
+        end
+
+        records
+      end
+
+      def insert_record(record, validate = true, raise = false)
+        ensure_not_nested
+
+        if record.new_record?
+          if raise
+            record.save!(:validate => validate)
+          else
+            return unless record.save(:validate => validate)
+          end
+        end
+
+        save_through_record(record)
+        update_counter(1)
+        record
+      end
+
+      private
+
+        def through_association
+          @through_association ||= owner.association(through_reflection.name)
+        end
+
+        # We temporarily cache through record that has been build, because if we build a
+        # through record in build_record and then subsequently call insert_record, then we
+        # want to use the exact same object.
+        #
+        # However, after insert_record has been called, we clear the cache entry because
+        # we want it to be possible to have multiple instances of the same record in an
+        # association
+        def build_through_record(record)
+          @through_records[record.object_id] ||= begin
+            ensure_mutable
+
+            through_record = through_association.build
+            through_record.send("#{source_reflection.name}=", record)
+            through_record
+          end
+        end
+
+        def save_through_record(record)
+          build_through_record(record).save!
+        ensure
+          @through_records.delete(record.object_id)
+        end
+
+        def build_record(attributes)
+          ensure_not_nested
+
+          record = super(attributes)
+
+          inverse = source_reflection.inverse_of
+          if inverse
+            if inverse.macro == :has_many
+              record.send(inverse.name) << build_through_record(record)
+            elsif inverse.macro == :has_one
+              record.send("#{inverse.name}=", build_through_record(record))
+            end
+          end
+
+          record
+        end
+
+        def target_reflection_has_associated_record?
+          !(through_reflection.macro == :belongs_to && owner[through_reflection.foreign_key].blank?)
+        end
+
+        def update_through_counter?(method)
+          case method
+          when :destroy
+            !inverse_updates_counter_cache?(through_reflection)
+          when :nullify
+            false
+          else
+            true
+          end
+        end
+
+        def delete_records(records, method)
+          ensure_not_nested
+
+          # This is unoptimised; it will load all the target records
+          # even when we just want to delete everything.
+          records = load_target if records == :all
+
+          scope = through_association.scope
+          scope.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(records)
+
+          if source_reflection.options[:counter_cache]
+            counter = source_reflection.counter_cache_column
+            klass.decrement_counter counter, records.map(&:id)
+          end
+
+          if through_reflection.macro == :has_many && update_through_counter?(method)
+            update_counter(-count, through_reflection)
+          end
+
+          update_counter(-count)
+        end
+
+        def through_records_for(record)
+          attributes = construct_join_attributes(record)
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+        end
+
+        def delete_through_records(records)
+          records.each do |record|
+            through_records = through_records_for(record)
+
+            if through_reflection.macro == :has_many
+              through_records.each { |r| through_association.target.delete(r) }
+            else
+              if through_records.include?(through_association.target)
+                through_association.target = nil
+              end
+            end
+
+            @through_records.delete(record.object_id)
+          end
+        end
+
+        def find_target
+          return [] unless target_reflection_has_associated_record?
+          scope.to_a
+        end
+
+        # NOTE - not sure that we can actually cope with inverses here
+        def invertible_for?(record)
+          false
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_one_association.rb

@@ -0,0 +1,102 @@
+
+module ActiveRecord
+  # = Active Record Belongs To Has One Association
+  module Associations
+    class HasOneAssociation < SingularAssociation #:nodoc:
+
+      def handle_dependency
+        case options[:dependent]
+        when :restrict, :restrict_with_exception
+          raise ActiveRecord::DeleteRestrictionError.new(reflection.name) if load_target
+
+        when :restrict_with_error
+          if load_target
+            record = klass.human_attribute_name(reflection.name).downcase
+            owner.errors.add(:base, :"restrict_dependent_destroy.one", record: record)
+            false
+          end
+
+        else
+          delete
+        end
+      end
+
+      def replace(record, save = true)
+        raise_on_type_mismatch!(record) if record
+        load_target
+
+        return self.target if !(target || record)
+        if (target != record) || record.changed?
+          transaction_if(save) do
+            remove_target!(options[:dependent]) if target && !target.destroyed?
+
+            if record
+              set_owner_attributes(record)
+              set_inverse_instance(record)
+
+              if owner.persisted? && save && !record.save
+                nullify_owner_attributes(record)
+                set_owner_attributes(target) if target
+                raise RecordNotSaved, "Failed to save the new associated #{reflection.name}."
+              end
+            end
+          end
+        end
+
+        self.target = record
+      end
+
+      def delete(method = options[:dependent])
+        if load_target
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            when :nullify
+              target.update_columns(reflection.foreign_key => nil)
+          end
+        end
+      end
+
+      private
+
+        # 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 remove_target!(method)
+          case method
+            when :delete
+              target.delete
+            when :destroy
+              target.destroy
+            else
+              nullify_owner_attributes(target)
+
+              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 after its foreign key was set to nil."
+              end
+          end
+        end
+
+        def nullify_owner_attributes(record)
+          record[reflection.foreign_key] = nil
+        end
+
+        def transaction_if(value)
+          if value
+            reflection.klass.transaction { yield }
+          else
+            yield
+          end
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_one_through_association.rb

@@ -0,0 +1,36 @@
+module ActiveRecord
+  # = Active Record Has One Through Association
+  module Associations
+    class HasOneThroughAssociation < HasOneAssociation #:nodoc:
+      include ThroughAssociation
+
+      def replace(record)
+        create_through_record(record)
+        self.target = record
+      end
+
+      private
+
+        def create_through_record(record)
+          ensure_not_nested
+
+          through_proxy  = owner.association(through_reflection.name)
+          through_record = through_proxy.send(:load_target)
+
+          if through_record && !record
+            through_record.destroy
+          elsif record
+            attributes = construct_join_attributes(record)
+
+            if through_record
+              through_record.update(attributes)
+            elsif owner.new_record?
+              through_proxy.build(attributes)
+            else
+              through_proxy.create(attributes)
+            end
+          end
+        end
+    end
+  end
+end