activerecord 1.0.0 → 1.1.0

data/lib/active_record/associations/association_collection.rb

@@ -3,7 +3,7 @@ module ActiveRecord
     class AssociationCollection #:nodoc:
       alias_method :proxy_respond_to?, :respond_to?
       instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?|^proxy_respond_to\?)/ }
-      
+
       def initialize(owner, association_name, association_class_name, association_class_primary_key_name, options)
         @owner = owner
         @options = options
@@ -13,45 +13,99 @@ module ActiveRecord
       end
       
       def method_missing(symbol, *args, &block)
-        load_collection_to_array
-        @collection_array.send(symbol, *args, &block)
+        load_collection
+        @collection.send(symbol, *args, &block)
       end
   
       def to_ary
-        load_collection_to_array
-        @collection_array.to_ary
+        load_collection
+        @collection.to_ary
       end
-      
+  
       def respond_to?(symbol)
         proxy_respond_to?(symbol) || [].respond_to?(symbol)
       end
+
+      def loaded?
+        !@collection.nil?
+      end
       
       def reload
-        @collection_array = nil
+        @collection = nil
       end
-      
-      def concat(*records)
-        records.flatten!
-        records.each {|record| self << record; }
+
+      # 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 <<(*records)
+        flatten_deeper(records).each do |record|
+          raise_on_type_mismatch(record)
+          insert_record(record)
+          @collection << record if loaded?
+        end
+        self
+      end
+
+      alias_method :push, :<<
+      alias_method :concat, :<<
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        records.each { |record| raise_on_type_mismatch(record) }
+        delete_records(records)
+        records.each { |record| @collection.delete(record) } if loaded?
       end
       
       def destroy_all
-        load_collection_to_array
-        @collection_array.each { |object| object.destroy  }
-        @collection_array = []
+        each { |record| record.destroy }
+        @collection = []
       end
       
       def size
-        (@collection_array.nil?) ? count_records : @collection_array.size
+        if loaded? then @collection.size else count_records end
       end
       
       def empty?
         size == 0
       end
       
+      def uniq(collection = self)
+        collection.inject([]) { |uniq_records, record| uniq_records << record unless uniq_records.include?(record); uniq_records }
+      end
+      
       alias_method :length, :size
+
+      protected
+        def loaded?
+          not @collection.nil?
+        end
+
+        def quoted_record_ids(records)
+          records.map { |record| "'#{@association_class.send(:sanitize, record.id)}'" }.join(',')
+        end
+
+        def interpolate_sql_options!(options, *keys)
+          keys.each { |key| options[key] &&= interpolate_sql(options[key]) }
+        end
+
+        def interpolate_sql(sql, record = nil)
+          @owner.send(:interpolate_sql, sql, record)
+        end
       
       private
+        def load_collection
+          begin
+            @collection = find_all_records unless loaded?
+          rescue ActiveRecord::RecordNotFound
+            @collection = []
+          end
+        end
+
+        def raise_on_type_mismatch(record)
+          raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
+        end
+
+
         def load_collection_to_array
           return unless @collection_array.nil? 
           begin
@@ -65,6 +119,11 @@ module ActiveRecord
           records = [records] unless records.is_a?(Array) || records.is_a?(ActiveRecord::Associations::AssociationCollection)
           records.dup
         end
+
+        # Array#flatten has problems with rescursive arrays. Going one level deeper solves the majority of the problems.
+        def flatten_deeper(array)
+          array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
+        end
     end
   end
 end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,45 +1,106 @@
 module ActiveRecord
   module Associations
-    class HasAndBelongsToManyCollection < AssociationCollection #:nodoc:
+    class HasAndBelongsToManyAssociation < 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_foreign_key = options[:association_foreign_key] || Inflector.underscore(Inflector.demodulize(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}"
 
+        interpolate_sql_options!(options, :finder_sql, :delete_sql)
         @finder_sql = options[:finder_sql] ||
-              "SELECT t.* FROM #{association_table_name} t, #{@join_table} j " +
+              "SELECT t.*, j.* 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}"
+              "j.#{association_class_primary_key_name} = '#{@owner.id}' " +
+              (options[:conditions] ? " AND " + options[:conditions] : "") + " " +
+              "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?
+ 
+      # Removes all records from this association.  Returns +self+ so method calls may be chained.
+      def clear
+        return self if size == 0 # forces load_collection if hasn't happened already
+
+        if sql = @options[:delete_sql]
+          each { |record| @owner.connection.execute(sql) }
+        elsif @options[:conditions] 
+          sql = 
+            "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = '#{@owner.id}' " +
+            "AND #{@association_foreign_key} IN (#{collect { |record| record.id }.join(", ")})"
+          @owner.connection.execute(sql)
+        else
+          sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = '#{@owner.id}'"
+          @owner.connection.execute(sql)
+        end
+
+        @collection = []
+        self
       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?
+
+      def find(association_id = nil, &block)
+        if block_given? || @options[:finder_sql]
+          load_collection
+          @collection.find(&block)
+        else
+          if loaded?
+            find_all { |record| record.id == association_id.to_i }.first
+          else
+            find_all_records(@finder_sql.sub(/ORDER BY/, "AND j.#{@association_foreign_key} = '#{association_id}' ORDER BY")).first
+          end
+        end
       end
-        
+
+      def push_with_attributes(record, join_attributes = {})
+        raise_on_type_mismatch(record)
+        insert_record_with_join_attributes(record, join_attributes)
+        join_attributes.each { |key, value| record.send(:write_attribute, key, value) }
+        @collection << record if loaded?
+        self
+      end
+      
+      alias :concat_with_attributes :push_with_attributes
+
+      def size
+        @options[:uniq] ? count_records : super
+      end
+      
       protected
-        def find_all_records
-          @association_class.find_by_sql(@finder_sql)
+        def find_all_records(sql = @finder_sql)
+          records = @association_class.find_by_sql(sql)
+          @options[:uniq] ? uniq(records) : records
         end
             
         def count_records
-          load_collection_to_array
-          @collection_array.size
+          load_collection
+          @collection.size
+        end
+
+        def insert_record(record)
+          if @options[:insert_sql]
+            @owner.connection.execute(interpolate_sql(@options[:insert_sql], record))
+          else
+            sql = "INSERT INTO #{@join_table} (#{@association_class_primary_key_name}, #{@association_foreign_key}) VALUES ('#{@owner.id}','#{record.id}')"
+            @owner.connection.execute(sql)
+          end
+        end
+        
+        def insert_record_with_join_attributes(record, join_attributes)
+          attributes = { @association_class_primary_key_name => @owner.id, @association_foreign_key => record.id }.update(join_attributes)          
+          sql = 
+            "INSERT INTO #{@join_table} (#{@owner.send(:quoted_column_names, attributes).join(', ')}) " +
+            "VALUES (#{attributes.values.collect { |value| @owner.send(:quote, value) }.join(', ')})"
+          @owner.connection.execute(sql)
+        end
+
+        def delete_records(records)
+          if sql = @options[:delete_sql]
+            records.each { |record| @owner.connection.execute(sql) }
+          else
+            ids = quoted_record_ids(records)
+            sql = "DELETE FROM #{@join_table} WHERE #{@association_class_primary_key_name} = '#{@owner.id}' AND #{@association_foreign_key} IN (#{ids})"
+            @owner.connection.execute(sql)
+          end
         end
       end
   end

data/lib/active_record/associations/has_many_association.rb

@@ -3,76 +3,65 @@ module ActiveRecord
     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]
-        
+        @conditions = @association_class.send(:sanitize_conditions, options[:conditions])
+
         if options[:finder_sql]
-          @counter_sql = options[:finder_sql].gsub(/SELECT (.*) FROM/, "SELECT COUNT(*) FROM")
-          @finder_sql = options[:finder_sql]
+          @finder_sql = interpolate_sql(options[:finder_sql])
+          @counter_sql = @finder_sql.gsub(/SELECT (.*) FROM/i, "SELECT COUNT(*) FROM")
         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?
+          @finder_sql = "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + interpolate_sql(@conditions) : ""}"   
+          @counter_sql = "#{@association_class_primary_key_name} = '#{@owner.id}'#{@conditions ? " AND " + interpolate_sql(@conditions) : ""}"
         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)
+        # Can't use Base.create since the foreign key may be a protected attribute.
+        record = build(attributes)
         record.save
-
-        @collection_array << record unless @collection_array.nil?
-        
-        return record
+        @collection << record if loaded?
+        record
       end
 
       def build(attributes = {})
-        association = @association_class.new
-        association.attributes = attributes.merge({ "#{@association_class_primary_key_name}" => @owner.id})
-        association
+        record = @association_class.new(attributes)
+        record[@association_class_primary_key_name] = @owner.id
+        record
       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)
+          load_collection
+          @collection.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
-            )
+            "#{@association_class_primary_key_name} = '#{@owner.id}' " +
+            "#{@conditions ? " AND " + @conditions : ""} #{runtime_conditions ? " AND " + @association_class.send(:sanitize_conditions, runtime_conditions) : ""}",
+            orderings, 
+            limit, 
+            joins
+          )
         end
       end
 
       def find(association_id = nil, &block)
         if block_given? || @options[:finder_sql]
-          load_collection_to_array
-          return @collection_array.send(:find, &block)
+          load_collection
+          @collection.find(&block)
         else
-          @association_class.find_on_conditions(
-              association_id, "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"
-            )
+          @association_class.find_on_conditions(association_id,
+            "#{@association_class_primary_key_name} = '#{@owner.id}' #{@conditions ? " AND " + @conditions : ""}"
+          )
         end
       end
-      
+
+      # Removes all records from this association.  Returns +self+ so
+      # method calls may be chained.
+      def clear
+        @association_class.update_all("#{@association_class_primary_key_name} = NULL", "#{@association_class_primary_key_name} = '#{@owner.id}'")
+        @collection = []
+        self
+      end
+
       protected
         def find_all_records
           if @options[:finder_sql]
@@ -97,8 +86,17 @@ module ActiveRecord
         end
         
         def cached_counter_attribute_name
-          @association_name + "_count"
+          "#{@association_name}_count"
+        end
+
+        def insert_record(record)
+          record.update_attribute(@association_class_primary_key_name, @owner.id)
+        end
+
+        def delete_records(records)
+          ids = quoted_record_ids(records)
+          @association_class.update_all("#{@association_class_primary_key_name} = NULL", "#{@association_class_primary_key_name} = '#{@owner.id}' AND #{@association_class.primary_key} IN (#{ids})")
         end
     end
   end
-end
+end

data/lib/active_record/base.rb

@@ -111,7 +111,7 @@ module ActiveRecord #:nodoc:
   #   end
   # 
   #   user = User.create("preferences" => %w( one two three ))
-  #   User.find(user.id).preferences # => raises SerializationTypeMismatch
+  #   User.find(user.id).preferences    # raises SerializationTypeMismatch
   # 
   # == Single table inheritance
   #
@@ -220,7 +220,7 @@ module ActiveRecord #:nodoc:
       #   Person.find([7, 17]) # returns an array for objects with IDs in (7, 17)
       # +RecordNotFound+ is raised if no record can be found.
       def find(*ids)
-        ids = [ ids ].flatten.compact
+        ids = ids.flatten.compact.uniq
 
         if ids.length > 1
           ids_list = ids.map{ |id| "'#{sanitize(id)}'" }.join(", ")
@@ -234,7 +234,7 @@ module ActiveRecord #:nodoc:
         elsif ids.length == 1
           id = ids.first
           sql = "SELECT * FROM #{table_name} WHERE #{primary_key} = '#{sanitize(id)}'"
-          sql << " AND #{type_condition}" unless descents_from_active_record?
+          sql << " AND #{type_condition}" unless descends_from_active_record?
 
           if record = connection.select_one(sql, "#{name} Find")
             instantiate(record)
@@ -275,7 +275,7 @@ module ActiveRecord #:nodoc:
       def find_by_sql(sql)
         connection.select_all(sql, "#{name} Load").inject([]) { |objects, record| objects << instantiate(record) }
       end
-    
+      
       # Returns the object for the first record responding to the conditions in +conditions+, 
       # such as "group = 'master'". If more than one record is returned from the query, it's the first that'll
       # be used to create the object. In such cases, it might be beneficial to also specify 
@@ -461,7 +461,7 @@ module ActiveRecord #:nodoc:
 
       # Defines the column name for use with single table inheritance -- can be overridden in subclasses.
       def inheritance_column
-	      "type"
+        "type"
       end
 
       # Turns the +table_name+ back into a class name following the reverse rules of +table_name+.
@@ -485,7 +485,19 @@ module ActiveRecord #:nodoc:
       # Returns an array of columns objects where the primary id, all columns ending in "_id" or "_count", 
       # and columns used for single table inheritance has been removed.
       def content_columns
-        columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+        @content_columns ||= columns.reject { |c| c.name == primary_key || c.name =~ /(_id|_count)$/ || c.name == inheritance_column }
+      end
+
+      # Returns a hash of all the methods added to query each of the columns in the table with the name of the method as the key
+      # and true as the value. This makes it possible to do O(1) lookups in respond_to? to check if a given method for attribute
+      # is available. 
+      def column_methods_hash
+        @dynamic_methods_hash ||= columns_hash.keys.inject(Hash.new(false)) do |methods, attr|
+          methods[attr.to_sym]       = true
+          methods["#{attr}=".to_sym] = true
+          methods["#{attr}?".to_sym] = true
+          methods
+        end
       end
 
       # Transforms attribute key names into a more humane format, such as "First name" instead of "first_name". Example:
@@ -494,7 +506,7 @@ module ActiveRecord #:nodoc:
         attribute_key_name.gsub(/_/, " ").capitalize unless attribute_key_name.nil?
       end
       
-      def descents_from_active_record? # :nodoc:
+      def descends_from_active_record? # :nodoc:
         superclass == Base
       end
 
@@ -513,10 +525,12 @@ module ActiveRecord #:nodoc:
       #     project.milestones << Milestone.find_all
       #   end
       def benchmark(title)
+        result = nil
         logger.level = Logger::ERROR
-        bm = Benchmark.measure { yield }
+        bm = Benchmark.measure { result = yield }
         logger.level = Logger::DEBUG
         logger.info "#{title} (#{sprintf("%f", bm.real)})"
+        return result
       end
 
       private
@@ -531,7 +545,7 @@ module ActiveRecord #:nodoc:
         # Returns true if the +record+ has a single table inheritance column and is using it.
         def record_with_type?(record)
           record.include?(inheritance_column) && !record[inheritance_column].nil? && 
-	           !record[inheritance_column].empty?
+            !record[inheritance_column].empty?
         end
         
         # Returns the name of the type of the record using the current module as a prefix. So descendents of
@@ -543,12 +557,12 @@ module ActiveRecord #:nodoc:
         # Adds a sanitized version of +conditions+ to the +sql+ string. Note that it's the passed +sql+ string is changed.
         def add_conditions!(sql, conditions)
           sql << "WHERE #{sanitize_conditions(conditions)} " unless conditions.nil?
-          sql << (conditions.nil? ? "WHERE " : " AND ") + type_condition unless descents_from_active_record?
+          sql << (conditions.nil? ? "WHERE " : " AND ") + type_condition unless descends_from_active_record?
         end
         
         def type_condition
           " (" + subclasses.inject("#{inheritance_column} = '#{Inflector.demodulize(name)}' ") do |condition, subclass| 
-            condition << "OR #{inheritance_column} = '#{Inflector.demodulize(subclass.name)}' "
+            condition << "OR #{inheritance_column} = '#{Inflector.demodulize(subclass.name)}'"
           end + ") "
         end
 
@@ -614,7 +628,7 @@ module ActiveRecord #:nodoc:
       # Every Active Record class must use "id" as their primary ID. This getter overwrites the native
       # id method, which isn't being used in this context.
       def id
-        read_attribute(self.class.primary_key)
+        read_attribute(self.class.primary_key) unless new_record?
       end
       
       # Sets the primary ID.
@@ -716,20 +730,30 @@ module ActiveRecord #:nodoc:
       def column_for_attribute(name)
         self.class.columns_hash[name]
       end
-      
+            
       # Returns true if the +comparison_object+ is of the same type and has the same id.
       def ==(comparison_object)
         comparison_object.instance_of?(self.class) && comparison_object.id == id
       end
 
+      # Delegates to ==
+      def eql?(comparison_object)
+        self == (comparison_object)
+      end
+      
+      # Delegates to id in order to allow two records of the same type and id to work with something like:
+      #   [ Person.find(1), Person.find(2), Person.find(3) ] & [ Person.find(1), Person.find(4) ] # => [ Person.find(1) ]
+      def hash
+        id
+      end
+
       # For checking respond_to? without searching the attributes (which is faster).
       alias_method :respond_to_without_attributes?, :respond_to?
 
       # A Person object with a name attribute can ask person.respond_to?("name"), person.respond_to?("name="), and
       # person.respond_to?("name?") which will all return true.
       def respond_to?(method)
-        @@dynamic_methods ||= attribute_names + attribute_names.collect { |attr| attr + "=" } + attribute_names.collect { |attr| attr + "?" }
-        @@dynamic_methods.include?(method.to_s) ? true : respond_to_without_attributes?(method)
+        self.class.column_methods_hash[method.to_sym] || respond_to_without_attributes?(method)
       end
 
     private
@@ -754,7 +778,7 @@ module ActiveRecord #:nodoc:
           "(#{quoted_column_names.join(', ')}) " +
           "VALUES(#{attributes_with_quotes.values.join(', ')})",
           "#{self.class.name} Create",
-      	  self.class.primary_key, self.id
+          self.class.primary_key, self.id
         )
         
         @new_record = false
@@ -765,9 +789,9 @@ module ActiveRecord #:nodoc:
       # set Reply[Reply.inheritance_column] = "Reply" yourself. No such attribute would be set for objects of the 
       # Message class in that example.
       def ensure_proper_type
-        unless self.class.descents_from_active_record?
-	        write_attribute(self.class.inheritance_column, Inflector.demodulize(self.class.name))
-	      end
+        unless self.class.descends_from_active_record?
+          write_attribute(self.class.inheritance_column, Inflector.demodulize(self.class.name))
+        end
       end
 
       # Allows access to the object attributes, which are held in the @attributes hash, as were
@@ -781,11 +805,13 @@ module ActiveRecord #:nodoc:
       def method_missing(method_id, *arguments)
         method_name = method_id.id2name
       
+      
+      
         if method_name =~ read_method? && @attributes.include?($1)
           return read_attribute($1)
-        elsif method_name =~ write_method?
+        elsif method_name =~ write_method? && @attributes.include?($1)
           write_attribute($1, arguments[0])
-        elsif method_name =~ query_method?
+        elsif method_name =~ query_method? && @attributes.include?($1)
           return query_attribute($1)
         else
           super
@@ -884,6 +910,12 @@ module ActiveRecord #:nodoc:
         connection.quote(value, column)
       end
 
+      # Interpolate custom sql string in instance context.
+      # Optional record argument is meant for custom insert_sql.
+      def interpolate_sql(sql, record = nil)
+        instance_eval("%(#{sql})")
+      end
+
       # Initializes the attributes array with keys matching the columns from the linked table and
       # the values matching the corresponding default value of that column, so
       # that a new instance, or one populated from a passed-in Hash, still has all the attributes
@@ -949,8 +981,8 @@ module ActiveRecord #:nodoc:
         hash.inject([]) { |list, pair| list << "#{pair.first} = #{pair.last}" }.join(", ")
       end
 
-      def quoted_column_names
-        attributes_with_quotes.keys.collect { |column_name| connection.quote_column_name(column_name) }
+      def quoted_column_names(attributes = attributes_with_quotes)
+        attributes.keys.collect { |column_name| connection.quote_column_name(column_name) }
       end
 
       def quote_columns(column_quoter, hash)
@@ -982,4 +1014,4 @@ module ActiveRecord #:nodoc:
         string[0..3] == "--- "
       end
   end
-end
+end