activerecord 1.0.0 → 3.0.0

data/lib/active_record/associations/association_proxy.rb

@@ -0,0 +1,295 @@
+require 'active_support/core_ext/array/wrap'
+
+module ActiveRecord
+  module Associations
+    # = Active Record Associations
+    #
+    # This is the root class of all association proxies:
+    #
+    #   AssociationProxy
+    #     BelongsToAssociation
+    #       HasOneAssociation
+    #     BelongsToPolymorphicAssociation
+    #     AssociationCollection
+    #       HasAndBelongsToManyAssociation
+    #       HasManyAssociation
+    #         HasManyThroughAssociation
+    #            HasOneThroughAssociation
+    #
+    # 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
+    # about is available in <tt>@reflection</tt>. That's an instance of the class
+    # ActiveRecord::Reflection::AssociationReflection.
+    #
+    # For example, given
+    #
+    #   class Blog < ActiveRecord::Base
+    #     has_many :posts
+    #   end
+    #
+    #   blog = Blog.find(:first)
+    #
+    # the association proxy in <tt>blog.posts</tt> has the object in +blog+ as
+    # <tt>@owner</tt>, the collection of its posts as <tt>@target</tt>, and
+    # the <tt>@reflection</tt> object represents a <tt>:has_many</tt> macro.
+    #
+    # This class has most of the basic instance methods removed, and delegates
+    # unknown methods to <tt>@target</tt> via <tt>method_missing</tt>. As a
+    # corner case, it even removes the +class+ method and that's why you get
+    #
+    #   blog.posts.class # => Array
+    #
+    # though the object behind <tt>blog.posts</tt> is not an Array, but an
+    # ActiveRecord::Associations::HasManyAssociation.
+    #
+    # The <tt>@target</tt> object is not \loaded until needed. For example,
+    #
+    #   blog.posts.count
+    #
+    # is computed directly through SQL and does not trigger by itself the
+    # instantiation of the actual post records.
+    class AssociationProxy #:nodoc:
+      alias_method :proxy_respond_to?, :respond_to?
+      alias_method :proxy_extend, :extend
+      delegate :to_param, :to => :proxy_target
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+
+      def initialize(owner, reflection)
+        @owner, @reflection = owner, reflection
+        @updated = false
+        reflection.check_validity!
+        Array.wrap(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+        reset
+      end
+
+      # Returns the owner of the proxy.
+      def proxy_owner
+        @owner
+      end
+
+      # Returns the reflection object that represents the association handled
+      # by the proxy.
+      def proxy_reflection
+        @reflection
+      end
+
+      # Returns the \target of the proxy, same as +target+.
+      def proxy_target
+        @target
+      end
+
+      # Does the proxy or its \target respond to +symbol+?
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || (load_target && @target.respond_to?(*args))
+      end
+
+      # Forwards <tt>===</tt> explicitly to the \target because the instance method
+      # removal above doesn't catch it. Loads the \target if needed.
+      def ===(other)
+        load_target
+        other === @target
+      end
+
+      # Returns the name of the table of the related class:
+      #
+      #   post.comments.aliased_table_name # => "comments"
+      #
+      def aliased_table_name
+        @reflection.klass.table_name
+      end
+
+      # Returns the SQL string that corresponds to the <tt>:conditions</tt>
+      # option of the macro, if given, or +nil+ otherwise.
+      def conditions
+        @conditions ||= interpolate_sql(@reflection.sanitized_conditions) if @reflection.sanitized_conditions
+      end
+      alias :sql_conditions :conditions
+
+      # Resets the \loaded flag to +false+ and sets the \target to +nil+.
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      # Reloads the \target and returns +self+ on success.
+      def reload
+        reset
+        load_target
+        self unless @target.nil?
+      end
+
+      # Has the \target been already \loaded?
+      def loaded?
+        @loaded
+      end
+
+      # Asserts the \target has been loaded setting the \loaded flag to +true+.
+      def loaded
+        @loaded = true
+      end
+
+      # Returns the target of this proxy, same as +proxy_target+.
+      def target
+        @target
+      end
+
+      # Sets the target of this proxy to <tt>\target</tt>, and the \loaded flag to +true+.
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      # Forwards the call to the target. Loads the \target if needed.
+      def inspect
+        load_target
+        @target.inspect
+      end
+
+      def send(method, *args)
+        if proxy_respond_to?(method)
+          super
+        else
+          load_target
+          @target.send(method, *args)
+        end
+      end
+
+      protected
+        # Does the association have a <tt>:dependent</tt> option?
+        def dependent?
+          @reflection.options[:dependent]
+        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.table_name)
+          @reflection.klass.send(:sanitize_sql, sql, table_name)
+        end
+
+        # Assigns the ID of the owner to the corresponding foreign key in +record+.
+        # If the association is polymorphic the type of the owner is also set.
+        def set_belongs_to_association_for(record)
+          if @reflection.options[:as]
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+          else
+            unless @owner.new_record?
+              primary_key = @reflection.options[:primary_key] || :id
+              record[@reflection.primary_key_name] = @owner.send(primary_key)
+            end
+          end
+        end
+
+        # Merges into +options+ the ones coming from the reflection.
+        def merge_options_from_reflection!(options)
+          options.reverse_merge!(
+            :group   => @reflection.options[:group],
+            :having  => @reflection.options[:having],
+            :limit   => @reflection.options[:limit],
+            :offset  => @reflection.options[:offset],
+            :joins   => @reflection.options[:joins],
+            :include => @reflection.options[:include],
+            :select  => @reflection.options[:select],
+            :readonly  => @reflection.options[:readonly]
+          )
+        end
+
+        # Forwards +with_scope+ to the reflection.
+        def with_scope(*args, &block)
+          @reflection.klass.send :with_scope, *args, &block
+        end
+
+      private
+        # Forwards any missing method call to the \target.
+        def method_missing(method, *args)
+          if load_target
+            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
+              @target.send(method, *args)
+            end
+          end
+        end
+
+        # Loads the \target if needed and returns it.
+        #
+        # This method is abstract in the sense that it relies on +find_target+,
+        # which is expected to be provided by descendants.
+        #
+        # If the \target is already \loaded it is just returned. Thus, you can call
+        # +load_target+ unconditionally to get the \target.
+        #
+        # ActiveRecord::RecordNotFound is rescued within the method, and it is
+        # not reraised. The proxy is \reset and +nil+ is the return value.
+        def load_target
+          return nil unless defined?(@loaded)
+
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
+            @target = find_target
+          end
+
+          @loaded = true
+          @target
+        rescue ActiveRecord::RecordNotFound
+          reset
+        end
+
+        # Can be overwritten by associations that might have the foreign key
+        # available for an association without having the object itself (and
+        # still being a new record). Currently, only +belongs_to+ presents
+        # this scenario (both vanilla and polymorphic).
+        def foreign_key_present
+          false
+        end
+
+        # Raises ActiveRecord::AssociationTypeMismatch unless +record+ is of
+        # the kind of the class of the associated objects. Meant to be used as
+        # a sanity check when you are about to assign an associated record.
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(@reflection.klass) || record.is_a?(@reflection.class_name.constantize)
+            message = "#{@reflection.class_name}(##{@reflection.klass.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise ActiveRecord::AssociationTypeMismatch, message
+          end
+        end
+
+        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.
+        def owner_quoted_id
+          @owner.quoted_id
+        end
+
+        def set_inverse_instance(record, instance)
+          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
+          inverse_relationship = @reflection.inverse_of
+          unless inverse_relationship.nil?
+            record.send(:"set_#{inverse_relationship.name}_target", instance)
+          end
+        end
+
+        # Override in subclasses
+        def we_can_set_the_inverse_on_this?(record)
+          false
+        end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_association.rb

@@ -0,0 +1,91 @@
+module ActiveRecord
+  # = Active Record Belongs To Associations
+  module Associations
+    class BelongsToAssociation < AssociationProxy #:nodoc:
+      def create(attributes = {})
+        replace(@reflection.create_association(attributes))
+      end
+
+      def build(attributes = {})
+        replace(@reflection.build_association(attributes))
+      end
+
+      def replace(record)
+        counter_cache_name = @reflection.counter_cache_column
+
+        if record.nil?
+          if counter_cache_name && !@owner.new_record?
+            @reflection.klass.decrement_counter(counter_cache_name, previous_record_id) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = @owner[@reflection.primary_key_name] = nil
+        else
+          raise_on_type_mismatch(record)
+
+          if counter_cache_name && !@owner.new_record? && record.id != @owner[@reflection.primary_key_name]
+            @reflection.klass.increment_counter(counter_cache_name, record.id)
+            @reflection.klass.decrement_counter(counter_cache_name, @owner[@reflection.primary_key_name]) if @owner[@reflection.primary_key_name]
+          end
+
+          @target = (AssociationProxy === record ? record.target : record)
+          @owner[@reflection.primary_key_name] = record_id(record) unless record.new_record?
+          @updated = true
+        end
+
+        set_inverse_instance(record, @owner)
+
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+        def find_target
+          find_method = if @reflection.options[:primary_key]
+                          "find_by_#{@reflection.options[:primary_key]}"
+                        else
+                          "find"
+                        end
+
+          options = @reflection.options.dup
+          (options.keys - [:select, :include, :readonly]).each do |key|
+            options.delete key
+          end
+          options[:conditions] = conditions
+
+          the_target = @reflection.klass.send(find_method,
+            @owner[@reflection.primary_key_name],
+            options
+          ) if @owner[@reflection.primary_key_name]
+          set_inverse_instance(the_target, @owner)
+          the_target
+        end
+
+        def foreign_key_present
+          !@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
+
+        def previous_record_id
+          @previous_record_id ||= if @reflection.options[:primary_key]
+                                    previous_record = @owner.send(@reflection.name)
+                                    previous_record.nil? ? nil : previous_record.id
+                                  else
+                                    @owner[@reflection.primary_key_name]
+                                  end
+        end
+    end
+  end
+end

data/lib/active_record/associations/belongs_to_polymorphic_association.rb

@@ -0,0 +1,78 @@
+module ActiveRecord
+  # = Active Record Belongs To Polymorphic Association
+  module Associations
+    class BelongsToPolymorphicAssociation < AssociationProxy #:nodoc:
+      def replace(record)
+        if record.nil?
+          @target = @owner[@reflection.primary_key_name] = @owner[@reflection.options[:foreign_type]] = nil
+        else
+          @target = (AssociationProxy === record ? record.target : record)
+
+          @owner[@reflection.primary_key_name] = record_id(record)
+          @owner[@reflection.options[:foreign_type]] = record.class.base_class.name.to_s
+
+          @updated = true
+        end
+
+        set_inverse_instance(record, @owner)
+        loaded
+        record
+      end
+
+      def updated?
+        @updated
+      end
+
+      private
+
+        # 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)
+          if @reflection.has_inverse?
+            inverse_association = @reflection.polymorphic_inverse_of(record.class)
+            inverse_association && inverse_association.macro == :has_one
+          else
+            false
+          end
+        end
+
+        def set_inverse_instance(record, instance)
+          return if record.nil? || !we_can_set_the_inverse_on_this?(record)
+          inverse_relationship = @reflection.polymorphic_inverse_of(record.class)
+          unless inverse_relationship.nil?
+            record.send(:"set_#{inverse_relationship.name}_target", instance)
+          end
+        end
+
+        def find_target
+          return nil if association_class.nil?
+
+          target =
+            if @reflection.options[:conditions]
+              association_class.find(
+                @owner[@reflection.primary_key_name],
+                :select     => @reflection.options[:select],
+                :conditions => conditions,
+                :include    => @reflection.options[:include]
+              )
+            else
+              association_class.find(@owner[@reflection.primary_key_name], :select => @reflection.options[:select], :include => @reflection.options[:include])
+            end
+          set_inverse_instance(target, @owner)
+          target
+        end
+
+        def foreign_key_present
+          !@owner[@reflection.primary_key_name].nil?
+        end
+
+        def record_id(record)
+          record.send(@reflection.options[:primary_key] || :id)
+        end
+
+        def association_class
+          @owner[@reflection.options[:foreign_type]] ? @owner[@reflection.options[:foreign_type]].constantize : nil
+        end
+    end
+  end
+end

data/lib/active_record/associations/has_and_belongs_to_many_association.rb

@@ -1,46 +1,137 @@
 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}"
+    class HasAndBelongsToManyAssociation < AssociationCollection #:nodoc:
+      def create(attributes = {})
+        create_record(attributes) { |record| insert_record(record) }
       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?
+
+      def create!(attributes = {})
+        create_record(attributes) { |record| insert_record(record, true) }
+      end
+
+      def columns
+        @reflection.columns(@reflection.options[:join_table], "#{@reflection.options[:join_table]} Columns")
+      end
+
+      def reset_column_information
+        @reflection.reset_column_information
       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 has_primary_key?
+        @has_primary_key ||= @owner.connection.supports_primary_key? && @owner.connection.primary_key(@reflection.options[:join_table])
       end
-        
+
       protected
-        def find_all_records
-          @association_class.find_by_sql(@finder_sql)
+        def construct_find_options!(options)
+          options[:joins]      = Arel::SqlLiteral.new @join_sql
+          options[:readonly]   = finding_with_ambiguous_select?(options[:select] || @reflection.options[:select])
+          options[:select]   ||= (@reflection.options[:select] || Arel::SqlLiteral.new('*'))
         end
-            
+
         def count_records
-          load_collection_to_array
-          @collection_array.size
+          load_target.size
         end
-      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)
+            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])
+            timestamps = record_timestamp_columns(record)
+            timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
+
+            attributes = columns.inject({}) do |attrs, column|
+              name = column.name
+              case name.to_s
+                when @reflection.primary_key_name.to_s
+                  attrs[relation[name]] = @owner.id
+                when @reflection.association_foreign_key.to_s
+                  attrs[relation[name]] = record.id
+                when *timestamps
+                  attrs[relation[name]] = timezone
+                else
+                  if record.has_attribute?(name)
+                    value = @owner.send(:quote_value, record[name], column)
+                    attrs[relation[name]] = value unless value.nil?
+                  end
+              end
+              attrs
+            end
+
+            relation.insert(attributes)
+          end
+
+          return true
+        end
+
+        def delete_records(records)
+          if sql = @reflection.options[:delete_sql]
+            records.each { |record| @owner.connection.delete(interpolate_sql(sql, record)) }
+          else
+            relation = Arel::Table.new(@reflection.options[:join_table])
+            relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
+              and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }))
+            ).delete
+          end
+        end
+
+        def construct_sql
+          if @reflection.options[:finder_sql]
+            @finder_sql = interpolate_sql(@reflection.options[:finder_sql])
+          else
+            @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
+            @finder_sql << " AND (#{conditions})" if conditions
+          end
+
+          @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}"
+
+          construct_counter_sql
+        end
+
+        def construct_scope
+          { :find => {  :conditions => @finder_sql,
+                        :joins => @join_sql,
+                        :readonly => false,
+                        :order => @reflection.options[:order],
+                        :include => @reflection.options[:include],
+                        :limit => @reflection.options[:limit] } }
+        end
+
+        # Join tables with additional columns on top of the two foreign keys must be considered
+        # ambiguous unless a select clause has been explicitly defined. Otherwise you can get
+        # broken records back, if, for example, the join column also has an id column. This will
+        # then overwrite the id column of the records coming back.
+        def finding_with_ambiguous_select?(select_clause)
+          !select_clause && columns.size != 2
+        end
+
+      private
+        def create_record(attributes, &block)
+          # Can't use Base.create because the foreign key may be a protected attribute.
+          ensure_owner_is_not_new
+          if attributes.is_a?(Array)
+            attributes.collect { |attr| create(attr) }
+          else
+            build_record(attributes, &block)
+          end
+        end
+
+        def record_timestamp_columns(record)
+          if record.record_timestamps
+            record.send(:all_timestamp_attributes).map { |x| x.to_s }
+          else
+            []
+          end
+        end
+    end
   end
-end
+end