activerecord 2.3.18 → 3.0.0.beta

data/lib/active_record/associations/association_collection.rb

@@ -11,7 +11,7 @@ module ActiveRecord
     # ones created with +build+ are added to the target. So, the target may be
     # non-empty and still lack children waiting to be read from the database.
     # If you look directly to the database you cannot assume that's the entire
-    # collection because new records may have beed added to the target, etc.
+    # collection because new records may have been added to the target, etc.
     #
     # If you need to work on all current children, new and existing records,
     # +load_target+ and the +loaded+ flag are your friends.
@@ -20,7 +20,22 @@ module ActiveRecord
         super
         construct_sql
       end
-      
+
+      delegate :group, :order, :limit, :joins, :where, :preload, :eager_load, :includes, :from, :lock, :readonly, :having, :to => :scoped
+
+      def select(select = nil, &block)
+        if block_given?
+          load_target
+          @target.select(&block)
+        else
+          scoped.select(select)
+        end
+      end
+
+      def scoped
+        with_scope(construct_scope) { @reflection.klass.scoped }
+      end
+
       def find(*args)
         options = args.extract_options!
 
@@ -37,27 +52,24 @@ module ActiveRecord
             load_target.select { |r| ids.include?(r.id) }
           end
         else
-          conditions = "#{@finder_sql}"
-          if sanitized_conditions = sanitize_sql(options[:conditions])
-            conditions << " AND (#{sanitized_conditions})"
-          end
-          
-          options[:conditions] = conditions
+          merge_options_from_reflection!(options)
+          construct_find_options!(options)
+
+          find_scope = construct_scope[:find].slice(:conditions, :order)
 
-          if options[:order] && @reflection.options[:order]
-            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
-          elsif @reflection.options[:order]
-            options[:order] = @reflection.options[:order]
+          with_scope(:find => find_scope) do
+            relation = @reflection.klass.send(:construct_finder_arel, options, @reflection.klass.send(:current_scoped_methods))
+
+            case args.first
+            when :first, :last
+              relation.send(args.first)
+            when :all
+              records = relation.all
+              @reflection.options[:uniq] ? uniq(records) : records
+            else
+              relation.find(*args)
+            end
           end
-          
-          # Build options specific to association
-          construct_find_options!(options)
-          
-          merge_options_from_reflection!(options)
-          
-          # Pass through args exactly as we received them.
-          args << options
-          @reflection.klass.find(*args)
         end
       end
 
@@ -164,14 +176,15 @@ module ActiveRecord
       # be used for the query. If no +:counter_sql+ was supplied, but +:finder_sql+ was set, the
       # descendant's +construct_sql+ method will have set :counter_sql automatically.
       # Otherwise, construct options and pass them with scope to the target class's +count+.
-      def count(*args)
+      def count(column_name = nil, options = {})
         if @reflection.options[:counter_sql]
           @reflection.klass.count_by_sql(@counter_sql)
         else
-          column_name, options = @reflection.klass.send(:construct_count_options_from_args, *args)
+          column_name, options = nil, column_name if column_name.is_a?(Hash)
+
           if @reflection.options[:uniq]
             # This is needed because 'SELECT count(DISTINCT *)..' is not valid SQL.
-            column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" if column_name == :all
+            column_name = "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key}" unless column_name
             options.merge!(:distinct => true)
           end
 
@@ -229,14 +242,13 @@ module ActiveRecord
         self
       end
 
-      # Destory all the records from this association.
+      # Destroy all the records from this association.
       #
       # See destroy for more info.
       def destroy_all
         load_target
-        destroy(@target).tap do
-          reset_target!
-        end
+        destroy(@target)
+        reset_target!
       end
 
       def create(attrs = {})
@@ -304,6 +316,15 @@ module ActiveRecord
         end
       end
 
+      # Returns true if the collection has more than 1 record. Equivalent to collection.size > 1.
+      def many?
+        if block_given?
+          method_missing(:many?) { |*block_args| yield(*block_args) }
+        else
+          size > 1
+        end
+      end
+
       def uniq(collection = self)
         seen = Set.new
         collection.inject([]) do |kept, record|
@@ -332,7 +353,6 @@ module ActiveRecord
 
       def include?(record)
         return false unless record.is_a?(@reflection.klass)
-        return include_in_memory?(record) if record.new_record?
         load_target if @reflection.options[:finder_sql] && !loaded?
         return @target.include?(record) if loaded?
         exists?(record)
@@ -345,22 +365,25 @@ module ActiveRecord
       protected
         def construct_find_options!(options)
         end
-        
+
+        def construct_counter_sql
+          if @reflection.options[:counter_sql]
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          elsif @reflection.options[:finder_sql]
+            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
+            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT\b(\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
+            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
+          else
+            @counter_sql = @finder_sql
+          end
+        end
+
         def load_target
           if !@owner.new_record? || foreign_key_present
             begin
               if !loaded?
                 if @target.is_a?(Array) && @target.any?
-                  @target = find_target.map do |f|
-                    i = @target.index(f)
-                    t = @target.delete_at(i) if i
-                    if t && t.changed?
-                      t
-                    else
-                      f.mark_for_destruction if t && t.marked_for_destruction?
-                      f
-                    end
-                  end + @target.find_all {|t| t.new_record?}
+                  @target = find_target + @target.find_all {|t| t.new_record? }
                 else
                   @target = find_target
                 end
@@ -373,29 +396,15 @@ module ActiveRecord
           loaded if target
           target
         end
-        
-        def method_missing(method, *args, &block)
-          case method.to_s
-          when 'find_or_create'
-            return find(:first, :conditions => args.first) || create(args.first)
-          when /^find_or_create_by_(.*)$/
-            rest = $1
-            find_args = pull_finder_args_from(DynamicFinderMatch.match(method).attribute_names, *args)
-            return  send("find_by_#{rest}", *find_args) ||
-                    method_missing("create_by_#{rest}", *args, &block)
-          when /^create_by_(.*)$/
-            return create($1.split('_and_').zip(args).inject({}) { |h,kv| k,v=kv ; h[k] = v ; h }, &block)
-          end
 
+        def method_missing(method, *args)
           if @target.respond_to?(method) || (!@reflection.klass.respond_to?(method) && Class.respond_to?(method))
             if block_given?
               super { |*block_args| yield(*block_args) }
             else
               super
             end
-          elsif @reflection.klass.scopes.include?(method)
-            @reflection.klass.scopes[method].call(self, *args)
-          else          
+          else
             with_scope(construct_scope) do
               if block_given?
                 @reflection.klass.send(method, *args) { |*block_args| yield(*block_args) }
@@ -430,36 +439,7 @@ module ActiveRecord
           records
         end
 
-        def add_record_to_target_with_callbacks(record)
-          callback(:before_add, record)
-          yield(record) if block_given?
-          @target ||= [] unless loaded?
-          @target << record unless @reflection.options[:uniq] && @target.include?(record)
-          callback(:after_add, record)
-          set_inverse_instance(record, @owner)
-          record
-        end
-
       private
-        # Separate the "finder" args from the "create" args given to a
-        # find_or_create_by_ call.  Returns an array with the
-        # parameter values in the same order as the keys in the
-        # "names" array.  This code was based on code in base.rb's
-        # method_missing method.
-        def pull_finder_args_from(names, *args)
-          attributes = names.collect { |name| name.intern }
-          attribute_hash = {}
-          args.each_with_index do |arg, i|
-            if arg.is_a?(Hash)
-              attribute_hash.merge! arg
-            else
-              attribute_hash[attributes[i]] = arg
-            end
-          end
-          attribute_hash = attribute_hash.with_indifferent_access
-          attributes.collect { |attr| attribute_hash[attr] }
-        end
-
         def create_record(attrs)
           attrs.update(@reflection.options[:conditions]) if @reflection.options[:conditions].is_a?(Hash)
           ensure_owner_is_not_new
@@ -483,6 +463,16 @@ module ActiveRecord
           end
         end
 
+        def add_record_to_target_with_callbacks(record)
+          callback(:before_add, record)
+          yield(record) if block_given?
+          @target ||= [] unless loaded?
+          @target << record unless @reflection.options[:uniq] && @target.include?(record)
+          callback(:after_add, record)
+          set_inverse_instance(record, @owner)
+          record
+        end
+
         def remove_records(*records)
           records = flatten_deeper(records)
           records.each { |record| raise_on_type_mismatch(record) }
@@ -497,15 +487,22 @@ module ActiveRecord
 
         def callback(method, record)
           callbacks_for(method).each do |callback|
-            ActiveSupport::Callbacks::Callback.new(method, callback, record).call(@owner, record)
+            case callback
+            when Symbol
+              @owner.send(callback, record)
+            when Proc
+              callback.call(@owner, record)
+            else
+              callback.send(method, @owner, record)
+            end
           end
         end
 
         def callbacks_for(callback_name)
           full_callback_name = "#{callback_name}_for_#{@reflection.name}"
           @owner.class.read_inheritable_attribute(full_callback_name.to_sym) || []
-        end
-
+        end   
+        
         def ensure_owner_is_not_new
           if @owner.new_record?
             raise ActiveRecord::RecordNotSaved, "You cannot call create unless the parent is saved"
@@ -516,18 +513,6 @@ module ActiveRecord
           args.first.kind_of?(Hash) || !(loaded? || @owner.new_record? || @reflection.options[:finder_sql] ||
                                          @target.any? { |record| record.new_record? } || args.first.kind_of?(Integer))
         end
-
-        def include_in_memory?(record)
-          if @reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-            @owner.send(proxy_reflection.through_reflection.name.to_sym).each do |source|
-              source_reflection_target = source.send(proxy_reflection.source_reflection.name)
-              return true if source_reflection_target.respond_to?(:include?) ? source_reflection_target.include?(record) : source_reflection_target == record
-            end
-            false
-          else
-            @target.include?(record)
-          end
-        end
     end
   end
 end

data/lib/active_record/associations/association_proxy.rb

@@ -156,21 +156,12 @@ module ActiveRecord
           @reflection.options[:dependent]
         end
 
-        # Returns a string with the IDs of +records+ joined with a comma, quoted
-        # if needed. The result is ready to be inserted into a SQL IN clause.
-        #
-        #   quoted_record_ids(records) # => "23,56,58,67"
-        #
-        def quoted_record_ids(records)
-          records.map { |record| record.quoted_id }.join(',')
-        end
-
         def interpolate_sql(sql, record = nil)
           @owner.send(:interpolate_sql, sql, record)
         end
 
         # Forwards the call to the reflection class.
-        def sanitize_sql(sql, table_name = @reflection.klass.quoted_table_name)
+        def sanitize_sql(sql, table_name = @reflection.klass.table_name)
           @reflection.klass.send(:sanitize_sql, sql, table_name)
         end
 
@@ -209,12 +200,17 @@ module ActiveRecord
 
       private
         # Forwards any missing method call to the \target.
-        def method_missing(method, *args, &block)
+        def method_missing(method, *args)
           if load_target
-            if @target.respond_to?(method)
-              @target.send(method, *args, &block)
+            unless @target.respond_to?(method)
+              message = "undefined method `#{method.to_s}' for \"#{@target}\":#{@target.class.to_s}"
+              raise NoMethodError, message
+            end
+
+            if block_given?
+              @target.send(method, *args)  { |*block_args| yield(*block_args) }
             else
-              super
+              @target.send(method, *args)
             end
           end
         end
@@ -260,10 +256,16 @@ module ActiveRecord
           end
         end
 
-        # Array#flatten has problems with recursive arrays. Going one level
-        # deeper solves the majority of the problems.
-        def flatten_deeper(array)
-          array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
+        if RUBY_VERSION < '1.9.2'
+          # Array#flatten has problems with recursive arrays before Ruby 1.9.2.
+          # Going one level deeper solves the majority of the problems.
+          def flatten_deeper(array)
+            array.collect { |element| (element.respond_to?(:flatten) && !element.is_a?(Hash)) ? element.flatten : element }.flatten
+          end
+        else
+          def flatten_deeper(array)
+            array.flatten
+          end
         end
 
         # Returns the ID of the owner, quoted if needed.

data/lib/active_record/associations/belongs_to_association.rb

@@ -36,11 +36,11 @@ module ActiveRecord
         loaded
         record
       end
-      
+
       def updated?
         @updated
       end
-      
+
       private
         def find_target
           find_method = if @reflection.options[:primary_key]
@@ -63,6 +63,12 @@ module ActiveRecord
           !@owner[@reflection.primary_key_name].nil?
         end
 
+        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
+        # has_one associations.
+        def we_can_set_the_inverse_on_this?(record)
+          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
+        end
+
         def record_id(record)
           record.send(@reflection.options[:primary_key] || :id)
         end
@@ -75,12 +81,6 @@ module ActiveRecord
                                     @owner[@reflection.primary_key_name]
                                   end
         end
-
-        # NOTE - for now, we're only supporting inverse setting from belongs_to back onto
-        # has_one associations.
-        def we_can_set_the_inverse_on_this?(record)
-          @reflection.has_inverse? && @reflection.inverse_of.macro == :has_one
-        end
     end
   end
 end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,11 +1,6 @@
 module ActiveRecord
   module Associations
     class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
-      def initialize(owner, reflection)
-        super
-        @primary_key_list = {}
-      end
-
       def create(attributes = {})
         create_record(attributes) { |record| insert_record(record) }
       end
@@ -23,9 +18,7 @@ module ActiveRecord
       end
 
       def has_primary_key?
-        return @has_primary_key unless @has_primary_key.nil?
-        @has_primary_key = (@owner.connection.supports_primary_key? &&
-          @owner.connection.primary_key(@reflection.options[:join_table]))
+        @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
       end
 
       protected
@@ -34,48 +27,40 @@ module ActiveRecord
           options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
           options[:select]   ||= (@reflection.options[:select] || '*')
         end
-        
+
         def count_records
           load_target.size
         end
 
         def insert_record(record, force = true, validate = true)
-          if has_primary_key?
-            raise ActiveRecord::ConfigurationError,
-              "Primary key is not allowed in a has_and_belongs_to_many join table (#{@reflection.options[:join_table]})."
-          end
-
           if record.new_record?
             if force
               record.save!
             else
-              return false unless record.save(validate)
+              return false unless record.save(:validate => validate)
             end
           end
 
           if @reflection.options[:insert_sql]
             @owner.connection.insert(interpolate_sql(@reflection.options[:insert_sql], record))
           else
+            relation = Arel::Table.new(@reflection.options[:join_table])
             attributes = columns.inject({}) do |attrs, column|
               case column.name.to_s
                 when @reflection.primary_key_name.to_s
-                  attrs[column.name] = owner_quoted_id
+                  attrs[relation[column.name]] = owner_quoted_id
                 when @reflection.association_foreign_key.to_s
-                  attrs[column.name] = record.quoted_id
+                  attrs[relation[column.name]] = record.quoted_id
                 else
                   if record.has_attribute?(column.name)
                     value = @owner.send(:quote_value, record[column.name], column)
-                    attrs[column.name] = value unless value.nil?
+                    attrs[relation[column.name]] = value unless value.nil?
                   end
               end
               attrs
             end
 
-            sql =
-              "INSERT INTO #{@owner.connection.quote_table_name @reflection.options[:join_table]} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
-              "VALUES (#{attributes.values.join(', ')})"
-
-            @owner.connection.insert(sql)
+            relation.insert(attributes)
           end
 
           return true
@@ -85,9 +70,10 @@ module ActiveRecord
           if sql = @reflection.options[:delete_sql]
             records.each { |record| @owner.connection.delete(interpolate_sql(sql, record)) }
           else
-            ids = quoted_record_ids(records)
-            sql = "DELETE FROM #{@owner.connection.quote_table_name @reflection.options[:join_table]} WHERE #{@reflection.primary_key_name} = #{owner_quoted_id} AND #{@reflection.association_foreign_key} IN (#{ids})"
-            @owner.connection.delete(sql)
+            relation = Arel::Table.new(@reflection.options[:join_table])
+            relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
+              and(Arel::Predicates::In.new(relation[@reflection.association_foreign_key], records.map(&:id)))
+            ).delete
           end
         end
 
@@ -101,15 +87,7 @@ module ActiveRecord
 
           @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
 
-          if @reflection.options[:counter_sql]
-            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-          elsif @reflection.options[:finder_sql]
-            # replace the SELECT clause with COUNT(*), preserving any hints within /* ... */
-            @reflection.options[:counter_sql] = @reflection.options[:finder_sql].sub(/SELECT (\/\*.*?\*\/ )?(.*)\bFROM\b/im) { "SELECT #{$1}COUNT(*) FROM" }
-            @counter_sql = interpolate_sql(@reflection.options[:counter_sql])
-          else
-            @counter_sql = @finder_sql
-          end
+          construct_counter_sql
         end
 
         def construct_scope