activerecord 3.2.19 → 5.0.0

data/lib/active_record/reflection.rb

@@ -1,5 +1,5 @@
-require 'active_support/core_ext/class/attribute'
-require 'active_support/core_ext/object/inclusion'
+require 'thread'
+require 'active_support/core_ext/string/filters'
 
 module ActiveRecord
   # = Active Record Reflection
@@ -7,35 +7,51 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
-      class_attribute :reflections
-      self.reflections = {}
+      class_attribute :_reflections, instance_writer: false
+      class_attribute :aggregate_reflections, instance_writer: false
+      self._reflections = {}
+      self.aggregate_reflections = {}
     end
 
-    # Reflection enables to interrogate Active Record classes and objects
-    # about their associations and aggregations. This information can,
-    # for example, be used in a form builder that takes an Active Record object
+    def self.create(macro, name, scope, options, ar)
+      klass = case macro
+              when :composed_of
+                AggregateReflection
+              when :has_many
+                HasManyReflection
+              when :has_one
+                HasOneReflection
+              when :belongs_to
+                BelongsToReflection
+              else
+                raise "Unsupported Macro: #{macro}"
+              end
+
+      reflection = klass.new(name, scope, options, ar)
+      options[:through] ? ThroughReflection.new(reflection) : reflection
+    end
+
+    def self.add_reflection(ar, name, reflection)
+      ar.clear_reflections_cache
+      ar._reflections = ar._reflections.merge(name.to_s => reflection)
+    end
+
+    def self.add_aggregate_reflection(ar, name, reflection)
+      ar.aggregate_reflections = ar.aggregate_reflections.merge(name.to_s => reflection)
+    end
+
+    # \Reflection enables the ability to examine the associations and aggregations of
+    # Active Record classes and objects. This information, for example,
+    # can be used in a form builder that takes an Active Record object
     # and creates input fields for all of the attributes depending on their type
     # and displays the associations to other objects.
     #
     # MacroReflection class has info for AggregateReflection and AssociationReflection
     # classes.
     module ClassMethods
-      def create_reflection(macro, name, options, active_record)
-        case macro
-          when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
-            klass = options[:through] ? ThroughReflection : AssociationReflection
-            reflection = klass.new(macro, name, options, active_record)
-          when :composed_of
-            reflection = AggregateReflection.new(macro, name, options, active_record)
-        end
-
-        self.reflections = self.reflections.merge(name => reflection)
-        reflection
-      end
-
       # Returns an array of AggregateReflection objects for all the aggregations in the class.
       def reflect_on_all_aggregations
-        reflections.values.grep(AggregateReflection)
+        aggregate_reflections.values
       end
 
       # Returns the AggregateReflection object for the named +aggregation+ (use the symbol).
@@ -43,7 +59,30 @@ module ActiveRecord
       #   Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection
       #
       def reflect_on_aggregation(aggregation)
-        reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
+        aggregate_reflections[aggregation.to_s]
+      end
+
+      # Returns a Hash of name of the reflection as the key and an AssociationReflection as the value.
+      #
+      #   Account.reflections # => {"balance" => AggregateReflection}
+      #
+      def reflections
+        @__reflections ||= begin
+          ref = {}
+
+          _reflections.each do |name, reflection|
+            parent_reflection = reflection.parent_reflection
+
+            if parent_reflection
+              parent_name = parent_reflection.name
+              ref[parent_name.to_s] = parent_reflection
+            else
+              ref[name] = reflection
+            end
+          end
+
+          ref
+        end
       end
 
       # Returns an array of AssociationReflection objects for all the
@@ -57,8 +96,9 @@ module ActiveRecord
       #   Account.reflect_on_all_associations(:has_many)  # returns an array of all has_many associations
       #
       def reflect_on_all_associations(macro = nil)
-        association_reflections = reflections.values.grep(AssociationReflection)
-        macro ? association_reflections.select { |reflection| reflection.macro == macro } : association_reflections
+        association_reflections = reflections.values
+        association_reflections.select! { |reflection| reflection.macro == macro } if macro
+        association_reflections
       end
 
       # Returns the AssociationReflection object for the +association+ (use the symbol).
@@ -67,64 +107,198 @@ module ActiveRecord
       #   Invoice.reflect_on_association(:line_items).macro  # returns :has_many
       #
       def reflect_on_association(association)
-        reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
+        reflections[association.to_s]
+      end
+
+      def _reflect_on_association(association) #:nodoc:
+        _reflections[association.to_s]
       end
 
       # Returns an array of AssociationReflection objects for all associations which have <tt>:autosave</tt> enabled.
       def reflect_on_all_autosave_associations
         reflections.values.select { |reflection| reflection.options[:autosave] }
       end
+
+      def clear_reflections_cache # :nodoc:
+        @__reflections = nil
+      end
     end
 
+    # Holds all the methods that are shared between MacroReflection and ThroughReflection.
+    #
+    #   AbstractReflection
+    #     MacroReflection
+    #       AggregateReflection
+    #       AssociationReflection
+    #         HasManyReflection
+    #         HasOneReflection
+    #         BelongsToReflection
+    #         HasAndBelongsToManyReflection
+    #     ThroughReflection
+    #       PolymorphicReflection
+    #         RuntimeReflection
+    class AbstractReflection # :nodoc:
+      def through_reflection?
+        false
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      # Returns a new, unsaved instance of the associated class. +attributes+ will
+      # be passed to the class's constructor.
+      def build_association(attributes, &block)
+        klass.new(attributes, &block)
+      end
+
+      def quoted_table_name
+        klass.quoted_table_name
+      end
+
+      def primary_key_type
+        klass.type_for_attribute(klass.primary_key)
+      end
 
-    # Abstract base class for AggregateReflection and AssociationReflection. Objects of
+      # Returns the class name for the macro.
+      #
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>'Money'</tt>
+      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
+      def class_name
+        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      end
+
+      JoinKeys = Struct.new(:key, :foreign_key) # :nodoc:
+
+      def join_keys(association_klass)
+        JoinKeys.new(foreign_key, active_record_primary_key)
+      end
+
+      def constraints
+        scope_chain.flatten
+      end
+
+      def counter_cache_column
+        if belongs_to?
+          if options[:counter_cache] == true
+            "#{active_record.name.demodulize.underscore.pluralize}_count"
+          elsif options[:counter_cache]
+            options[:counter_cache].to_s
+          end
+        else
+          options[:counter_cache] ? options[:counter_cache].to_s : "#{name}_count"
+        end
+      end
+
+      def inverse_of
+        return unless inverse_name
+
+        @inverse_of ||= klass._reflect_on_association inverse_name
+      end
+
+      def check_validity_of_inverse!
+        unless polymorphic?
+          if has_inverse? && inverse_of.nil?
+            raise InverseOfAssociationNotFoundError.new(self)
+          end
+        end
+      end
+
+      # 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_which_updates_counter_cache
+        return @inverse_which_updates_counter_cache if defined?(@inverse_which_updates_counter_cache)
+        @inverse_which_updates_counter_cache = klass.reflect_on_all_associations(:belongs_to).find do |inverse|
+          inverse.counter_cache_column == counter_cache_column
+        end
+      end
+      alias inverse_updates_counter_cache? inverse_which_updates_counter_cache
+
+      def inverse_updates_counter_in_memory?
+        inverse_of && inverse_which_updates_counter_cache == inverse_of
+      end
+
+      # Returns whether a counter cache should be used for this association.
+      #
+      # The counter_cache option must be given on either the owner or inverse
+      # association, and the column must be present on the owner.
+      def has_cached_counter?
+        options[:counter_cache] ||
+          inverse_which_updates_counter_cache && inverse_which_updates_counter_cache.options[:counter_cache] &&
+          !!active_record.columns_hash[counter_cache_column]
+      end
+
+      def counter_must_be_updated_by_has_many?
+        !inverse_updates_counter_in_memory? && has_cached_counter?
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}"
+      end
+
+      def chain
+        collect_join_chain
+      end
+    end
+
+    # Base class for AggregateReflection and AssociationReflection. Objects of
     # AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
-    class MacroReflection
+    class MacroReflection < AbstractReflection
       # Returns the name of the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:balance</tt>
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>:balance</tt>
       # <tt>has_many :clients</tt> returns <tt>:clients</tt>
       attr_reader :name
 
-      # Returns the macro type.
-      #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>:composed_of</tt>
-      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
-      attr_reader :macro
+      attr_reader :scope
 
       # Returns the hash of options used for the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>{ :class_name => "Money" }</tt>
-      # <tt>has_many :clients</tt> returns +{}+
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns <tt>{ class_name: "Money" }</tt>
+      # <tt>has_many :clients</tt> returns <tt>{}</tt>
       attr_reader :options
 
       attr_reader :active_record
 
       attr_reader :plural_name # :nodoc:
 
-      def initialize(macro, name, options, active_record)
-        @macro         = macro
+      def initialize(name, scope, options, active_record)
         @name          = name
+        @scope         = scope
         @options       = options
         @active_record = active_record
+        @klass         = options[:anonymous_class]
         @plural_name   = active_record.pluralize_table_names ?
                             name.to_s.pluralize : name.to_s
       end
 
+      def autosave=(autosave)
+        @automatic_inverse_of = false
+        @options[:autosave] = autosave
+        parent_reflection = self.parent_reflection
+        if parent_reflection
+          parent_reflection.autosave = autosave
+        end
+      end
+
       # Returns the class for the macro.
       #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns the Money class
+      # <tt>composed_of :balance, class_name: 'Money'</tt> returns the Money class
       # <tt>has_many :clients</tt> returns the Client class
       def klass
-        @klass ||= class_name.constantize
+        @klass ||= compute_class(class_name)
       end
 
-      # Returns the class name for the macro.
-      #
-      # <tt>composed_of :balance, :class_name => 'Money'</tt> returns <tt>'Money'</tt>
-      # <tt>has_many :clients</tt> returns <tt>'Client'</tt>
-      def class_name
-        @class_name ||= (options[:class_name] || derive_class_name).to_s
+      def compute_class(name)
+        name.constantize
       end
 
       # Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute,
@@ -133,14 +307,10 @@ module ActiveRecord
         super ||
           other_aggregation.kind_of?(self.class) &&
           name == other_aggregation.name &&
-          other_aggregation.options &&
+          !other_aggregation.options.nil? &&
           active_record == other_aggregation.active_record
       end
 
-      def sanitized_conditions #:nodoc:
-        @sanitized_conditions ||= klass.send(:sanitize_sql, options[:conditions]) if options[:conditions]
-      end
-
       private
         def derive_class_name
           name.to_s.camelize
@@ -151,6 +321,10 @@ module ActiveRecord
     # Holds all the meta-data about an aggregation as it was specified in the
     # Active Record class.
     class AggregateReflection < MacroReflection #:nodoc:
+      def mapping
+        mapping = options[:mapping] || [name, name]
+        mapping.first.is_a?(Array) ? mapping : [mapping]
+      end
     end
 
     # Holds all the meta-data about an association as it was specified in the
@@ -169,42 +343,46 @@ module ActiveRecord
       # a new association object. Use +build_association+ or +create_association+
       # instead. This allows plugins to hook into association object creation.
       def klass
-        @klass ||= active_record.send(:compute_type, class_name)
+        @klass ||= compute_class(class_name)
       end
 
-      def initialize(macro, name, options, active_record)
-        super
-        @collection = macro.in?([:has_many, :has_and_belongs_to_many])
+      def compute_class(name)
+        active_record.send(:compute_type, name)
       end
 
-      # Returns a new, unsaved instance of the associated class. +options+ will
-      # be passed to the class's constructor.
-      def build_association(*options, &block)
-        klass.new(*options, &block)
-      end
+      attr_reader :type, :foreign_type
+      attr_accessor :parent_reflection # Reflection
 
-      def table_name
-        @table_name ||= klass.table_name
-      end
-
-      def quoted_table_name
-        @quoted_table_name ||= klass.quoted_table_name
+      def initialize(name, scope, options, active_record)
+        super
+        @automatic_inverse_of = nil
+        @type         = options[:as] && (options[:foreign_type] || "#{options[:as]}_type")
+        @foreign_type = options[:foreign_type] || "#{name}_type"
+        @constructable = calculate_constructable(macro, options)
+        @association_scope_cache = {}
+        @scope_lock = Mutex.new
       end
 
-      def foreign_key
-        @foreign_key ||= options[:foreign_key] || derive_foreign_key
+      def association_scope_cache(conn, owner)
+        key = conn.prepared_statements
+        if polymorphic?
+          key = [key, owner._read_attribute(@foreign_type)]
+        end
+        @association_scope_cache[key] ||= @scope_lock.synchronize {
+          @association_scope_cache[key] ||= yield
+        }
       end
 
-      def foreign_type
-        @foreign_type ||= options[:foreign_type] || "#{name}_type"
+      def constructable? # :nodoc:
+        @constructable
       end
 
-      def type
-        @type ||= options[:as] && "#{options[:as]}_type"
+      def join_table
+        @join_table ||= options[:join_table] || derive_join_table
       end
 
-      def primary_key_column
-        @primary_key_column ||= klass.columns.find { |c| c.name == klass.primary_key }
+      def foreign_key
+        @foreign_key ||= options[:foreign_key] || derive_foreign_key.freeze
       end
 
       def association_foreign_key
@@ -220,74 +398,68 @@ module ActiveRecord
         @active_record_primary_key ||= options[:primary_key] || primary_key(active_record)
       end
 
-      def counter_cache_column
-        if options[:counter_cache] == true
-          "#{active_record.name.demodulize.underscore.pluralize}_count"
-        elsif options[:counter_cache]
-          options[:counter_cache].to_s
-        end
-      end
-
-      def columns(tbl_name, log_msg)
-        @columns ||= klass.connection.columns(tbl_name, log_msg)
-      end
-
-      def reset_column_information
-        @columns = nil
-      end
-
       def check_validity!
         check_validity_of_inverse!
       end
 
-      def check_validity_of_inverse!
-        unless options[:polymorphic]
-          if has_inverse? && inverse_of.nil?
-            raise InverseOfAssociationNotFoundError.new(self)
-          end
+      def check_preloadable!
+        return unless scope
+
+        if scope.arity > 0
+          raise ArgumentError, <<-MSG.squish
+            The association scope '#{name}' is instance dependent (the scope
+            block takes an argument). Preloading instance dependent scopes is
+            not supported.
+          MSG
         end
       end
+      alias :check_eager_loadable! :check_preloadable!
+
+      def join_id_for(owner) # :nodoc:
+        owner[active_record_primary_key]
+      end
 
       def through_reflection
         nil
       end
 
       def source_reflection
-        nil
+        self
       end
 
       # A chain of reflections from this one back to the owner. For more see the explanation in
       # ThroughReflection.
-      def chain
+      def collect_join_chain
         [self]
       end
 
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        @association_scope_cache.clear
+      end
+
       def nested?
         false
       end
 
-      # An array of arrays of conditions. Each item in the outside array corresponds to a reflection
-      # in the #chain. The inside arrays are simply conditions (and each condition may itself be
-      # a hash, array, arel predicate, etc...)
-      def conditions
-        [[options[:conditions]].compact]
+      # An array of arrays of scopes. Each item in the outside array corresponds to a reflection
+      # in the #chain.
+      def scope_chain
+        scope ? [[scope]] : [[]]
       end
 
-      alias :source_macro :macro
-
-      def has_inverse?
-        @options[:inverse_of]
+      def has_scope?
+        scope
       end
 
-      def inverse_of
-        if has_inverse?
-          @inverse_of ||= klass.reflect_on_association(options[:inverse_of])
-        end
+      def has_inverse?
+        inverse_name
       end
 
       def polymorphic_inverse_of(associated_class)
         if has_inverse?
-          if inverse_relationship = associated_class.reflect_on_association(options[:inverse_of])
+          if inverse_relationship = associated_class._reflect_on_association(options[:inverse_of])
             inverse_relationship
           else
             raise InverseOfAssociationNotFoundError.new(self, associated_class)
@@ -295,61 +467,138 @@ module ActiveRecord
         end
       end
 
+      # Returns the macro type.
+      #
+      # <tt>has_many :clients</tt> returns <tt>:has_many</tt>
+      def macro; raise NotImplementedError; end
+
       # Returns whether or not this association reflection is for a collection
       # association. Returns +true+ if the +macro+ is either +has_many+ or
       # +has_and_belongs_to_many+, +false+ otherwise.
       def collection?
-        @collection
+        false
       end
 
       # Returns whether or not the association should be validated as part of
       # the parent's validation.
       #
       # Unless you explicitly disable validation with
-      # <tt>:validate => false</tt>, validation will take place when:
+      # <tt>validate: false</tt>, validation will take place when:
       #
-      # * you explicitly enable validation; <tt>:validate => true</tt>
-      # * you use autosave; <tt>:autosave => true</tt>
+      # * you explicitly enable validation; <tt>validate: true</tt>
+      # * you use autosave; <tt>autosave: true</tt>
       # * the association is a +has_many+ association
       def validate?
-        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || macro == :has_many)
+        !options[:validate].nil? ? options[:validate] : (options[:autosave] == true || collection?)
       end
 
       # Returns +true+ if +self+ is a +belongs_to+ reflection.
-      def belongs_to?
-        macro == :belongs_to
+      def belongs_to?; false; end
+
+      # Returns +true+ if +self+ is a +has_one+ reflection.
+      def has_one?; false; end
+
+      def association_class; raise NotImplementedError; end
+
+      def polymorphic?
+        options[:polymorphic]
       end
 
-      def association_class
-        case macro
-        when :belongs_to
-          if options[:polymorphic]
-            Associations::BelongsToPolymorphicAssociation
-          else
-            Associations::BelongsToAssociation
-          end
-        when :has_and_belongs_to_many
-          Associations::HasAndBelongsToManyAssociation
-        when :has_many
-          if options[:through]
-            Associations::HasManyThroughAssociation
-          else
-            Associations::HasManyAssociation
+      VALID_AUTOMATIC_INVERSE_MACROS = [:has_many, :has_one, :belongs_to]
+      INVALID_AUTOMATIC_INVERSE_OPTIONS = [:conditions, :through, :polymorphic, :foreign_key]
+
+      def add_as_source(seed)
+        seed
+      end
+
+      def add_as_polymorphic_through(reflection, seed)
+        seed + [PolymorphicReflection.new(self, reflection)]
+      end
+
+      def add_as_through(seed)
+        seed + [self]
+      end
+
+      protected
+
+        def actual_source_reflection # FIXME: this is a horrible name
+          self
+        end
+
+      private
+
+        def calculate_constructable(macro, options)
+          true
+        end
+
+        # Attempts to find the inverse association name automatically.
+        # If it cannot find a suitable inverse association name, it returns
+        # nil.
+        def inverse_name
+          options.fetch(:inverse_of) do
+            if @automatic_inverse_of == false
+              nil
+            else
+              @automatic_inverse_of ||= automatic_inverse_of
+            end
           end
-        when :has_one
-          if options[:through]
-            Associations::HasOneThroughAssociation
-          else
-            Associations::HasOneAssociation
+        end
+
+        # returns either false or the inverse association name that it finds.
+        def automatic_inverse_of
+          if can_find_inverse_of_automatically?(self)
+            inverse_name = ActiveSupport::Inflector.underscore(options[:as] || active_record.name.demodulize).to_sym
+
+            begin
+              reflection = klass._reflect_on_association(inverse_name)
+            rescue NameError
+              # Give up: we couldn't compute the klass type so we won't be able
+              # to find any associations either.
+              reflection = false
+            end
+
+            if valid_inverse_reflection?(reflection)
+              return inverse_name
+            end
           end
+
+          false
+        end
+
+        # Checks if the inverse reflection that is returned from the
+        # +automatic_inverse_of+ method is a valid reflection. We must
+        # make sure that the reflection's active_record name matches up
+        # with the current reflection's klass name.
+        #
+        # Note: klass will always be valid because when there's a NameError
+        # from calling +klass+, +reflection+ will already be set to false.
+        def valid_inverse_reflection?(reflection)
+          reflection &&
+            klass.name == reflection.active_record.name &&
+            can_find_inverse_of_automatically?(reflection)
+        end
+
+        # Checks to see if the reflection doesn't have any options that prevent
+        # us from being able to guess the inverse automatically. First, the
+        # <tt>inverse_of</tt> option cannot be set to false. Second, we must
+        # have <tt>has_many</tt>, <tt>has_one</tt>, <tt>belongs_to</tt> associations.
+        # Third, we must not have options such as <tt>:polymorphic</tt> or
+        # <tt>:foreign_key</tt> which prevent us from correctly guessing the
+        # inverse association.
+        #
+        # Anything with a scope can additionally ruin our attempt at finding an
+        # inverse, so we exclude reflections with scopes.
+        def can_find_inverse_of_automatically?(reflection)
+          reflection.options[:inverse_of] != false &&
+            VALID_AUTOMATIC_INVERSE_MACROS.include?(reflection.macro) &&
+            !INVALID_AUTOMATIC_INVERSE_OPTIONS.any? { |opt| reflection.options[opt] } &&
+            !reflection.scope
         end
-      end
 
-      private
         def derive_class_name
-          class_name = name.to_s.camelize
+          class_name = name.to_s
           class_name = class_name.singularize if collection?
-          class_name
+          class_name.camelize
         end
 
         def derive_foreign_key
@@ -362,27 +611,130 @@ module ActiveRecord
           end
         end
 
+        def derive_join_table
+          ModelSchema.derive_join_table_name active_record.table_name, klass.table_name
+        end
+
         def primary_key(klass)
           klass.primary_key || raise(UnknownPrimaryKey.new(klass))
         end
     end
 
+    class HasManyReflection < AssociationReflection # :nodoc:
+      def macro; :has_many; end
+
+      def collection?; true; end
+
+      def association_class
+        if options[:through]
+          Associations::HasManyThroughAssociation
+        else
+          Associations::HasManyAssociation
+        end
+      end
+    end
+
+    class HasOneReflection < AssociationReflection # :nodoc:
+      def macro; :has_one; end
+
+      def has_one?; true; end
+
+      def association_class
+        if options[:through]
+          Associations::HasOneThroughAssociation
+        else
+          Associations::HasOneAssociation
+        end
+      end
+
+      private
+
+        def calculate_constructable(macro, options)
+          !options[:through]
+        end
+    end
+
+    class BelongsToReflection < AssociationReflection # :nodoc:
+      def macro; :belongs_to; end
+
+      def belongs_to?; true; end
+
+      def association_class
+        if polymorphic?
+          Associations::BelongsToPolymorphicAssociation
+        else
+          Associations::BelongsToAssociation
+        end
+      end
+
+      def join_keys(association_klass)
+        key = polymorphic? ? association_primary_key(association_klass) : association_primary_key
+        JoinKeys.new(key, foreign_key)
+      end
+
+      def join_id_for(owner) # :nodoc:
+        owner[foreign_key]
+      end
+
+      private
+
+        def calculate_constructable(macro, options)
+          !polymorphic?
+        end
+    end
+
+    class HasAndBelongsToManyReflection < AssociationReflection # :nodoc:
+      def initialize(name, scope, options, active_record)
+        super
+      end
+
+      def macro; :has_and_belongs_to_many; end
+
+      def collection?
+        true
+      end
+    end
+
     # Holds all the meta-data about a :through association as it was specified
     # in the Active Record class.
-    class ThroughReflection < AssociationReflection #:nodoc:
+    class ThroughReflection < AbstractReflection #:nodoc:
+      attr_reader :delegate_reflection
       delegate :foreign_key, :foreign_type, :association_foreign_key,
                :active_record_primary_key, :type, :to => :source_reflection
 
-      # Gets the source of the through reflection. It checks both a singularized
+      def initialize(delegate_reflection)
+        @delegate_reflection = delegate_reflection
+        @klass         = delegate_reflection.options[:anonymous_class]
+        @source_reflection_name = delegate_reflection.options[:source]
+      end
+
+      def through_reflection?
+        true
+      end
+
+      def klass
+        @klass ||= delegate_reflection.compute_class(class_name)
+      end
+
+      # Returns the source of the through reflection. It checks both a singularized
       # and pluralized form for <tt>:belongs_to</tt> or <tt>:has_many</tt>.
       #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings
-      #     has_many :tags, :through => :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   class Tagging < ActiveRecord::Base
+      #     belongs_to :post
+      #     belongs_to :tag
       #   end
       #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.source_reflection
+      #   # => <ActiveRecord::Reflection::BelongsToReflection: @name=:tag, @active_record=Tagging, @plural_name="tags">
+      #
       def source_reflection
-        @source_reflection ||= source_reflection_names.collect { |name| through_reflection.klass.reflect_on_association(name) }.compact.first
+        through_reflection.klass._reflect_on_association(source_reflection_name)
       end
 
       # Returns the AssociationReflection object specified in the <tt>:through</tt> option
@@ -390,14 +742,15 @@ module ActiveRecord
       #
       #   class Post < ActiveRecord::Base
       #     has_many :taggings
-      #     has_many :tags, :through => :taggings
+      #     has_many :tags, through: :taggings
       #   end
       #
       #   tags_reflection = Post.reflect_on_association(:tags)
-      #   taggings_reflection = tags_reflection.through_reflection
+      #   tags_reflection.through_reflection
+      #   # => <ActiveRecord::Reflection::HasManyReflection: @name=:taggings, @active_record=Post, @plural_name="taggings">
       #
       def through_reflection
-        @through_reflection ||= active_record.reflect_on_association(options[:through])
+        active_record._reflect_on_association(options[:through])
       end
 
       # Returns an array of reflections which are involved in this association. Each item in the
@@ -406,64 +759,83 @@ module ActiveRecord
       # The chain is built by recursively calling #chain on the source reflection and the through
       # reflection. The base case for the recursion is a normal association, which just returns
       # [self] as its #chain.
-      def chain
-        @chain ||= begin
-          chain = source_reflection.chain + through_reflection.chain
-          chain[0] = self # Use self so we don't lose the information from :source_type
-          chain
-        end
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
+      #
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.chain
+      #   # => [<ActiveRecord::Reflection::ThroughReflection: @delegate_reflection=#<ActiveRecord::Reflection::HasManyReflection: @name=:tags...>,
+      #         <ActiveRecord::Reflection::HasManyReflection: @name=:taggings, @options={}, @active_record=Post>]
+      #
+      def collect_join_chain
+        collect_join_reflections [self]
+      end
+
+      # This is for clearing cache on the reflection. Useful for tests that need to compare
+      # SQL queries on associations.
+      def clear_association_scope_cache # :nodoc:
+        delegate_reflection.clear_association_scope_cache
+        source_reflection.clear_association_scope_cache
+        through_reflection.clear_association_scope_cache
       end
 
       # Consider the following example:
       #
       #   class Person
       #     has_many :articles
-      #     has_many :comment_tags, :through => :articles
+      #     has_many :comment_tags, through: :articles
       #   end
       #
       #   class Article
       #     has_many :comments
-      #     has_many :comment_tags, :through => :comments, :source => :tags
+      #     has_many :comment_tags, through: :comments, source: :tags
       #   end
       #
       #   class Comment
       #     has_many :tags
       #   end
       #
-      # There may be conditions on Person.comment_tags, Article.comment_tags and/or Comment.tags,
+      # There may be scopes on Person.comment_tags, Article.comment_tags and/or Comment.tags,
       # but only Comment.tags will be represented in the #chain. So this method creates an array
-      # of conditions corresponding to the chain. Each item in the #conditions array corresponds
-      # to an item in the #chain, and is itself an array of conditions from an arbitrary number
-      # of relevant reflections, plus any :source_type or polymorphic :as constraints.
-      def conditions
-        @conditions ||= begin
-          conditions = source_reflection.conditions.map { |c| c.dup }
+      # of scopes corresponding to the chain.
+      def scope_chain
+        @scope_chain ||= begin
+          scope_chain = source_reflection.scope_chain.map(&:dup)
 
-          # Add to it the conditions from this reflection if necessary.
-          conditions.first << options[:conditions] if options[:conditions]
+          # Add to it the scope from this reflection (if any)
+          scope_chain.first << scope if scope
 
-          through_conditions = through_reflection.conditions
+          through_scope_chain = through_reflection.scope_chain.map(&:dup)
 
           if options[:source_type]
-            through_conditions.first << { foreign_type => options[:source_type] }
+            type = foreign_type
+            source_type = options[:source_type]
+            through_scope_chain.first << lambda { |object|
+              where(type => source_type)
+            }
           end
 
           # Recursively fill out the rest of the array from the through reflection
-          conditions += through_conditions
-
-          # And return
-          conditions
+          scope_chain + through_scope_chain
         end
       end
 
-      # The macro used by the source association
-      def source_macro
-        source_reflection.source_macro
+      def has_scope?
+        scope || options[:source_type] ||
+          source_reflection.has_scope? ||
+          through_reflection.has_scope?
+      end
+
+      def join_keys(association_klass)
+        source_reflection.join_keys(association_klass)
       end
 
       # A through association is nested if there would be more than one join table
       def nested?
-        chain.length > 2 || through_reflection.macro == :has_and_belongs_to_many
+        source_reflection.through_reflection? || through_reflection.through_reflection?
       end
 
       # We want to use the klass from this reflection, rather than just delegate straight to
@@ -472,20 +844,45 @@ module ActiveRecord
       def association_primary_key(klass = nil)
         # Get the "actual" source reflection if the immediate source reflection has a
         # source reflection itself
-        source_reflection = self.source_reflection
-        while source_reflection.source_reflection
-          source_reflection = source_reflection.source_reflection
-        end
-
-        source_reflection.options[:primary_key] || primary_key(klass || self.klass)
+        actual_source_reflection.options[:primary_key] || primary_key(klass || self.klass)
       end
 
-      # Gets an array of possible <tt>:through</tt> source reflection names:
+      # Gets an array of possible <tt>:through</tt> source reflection names in both singular and plural form.
+      #
+      #   class Post < ActiveRecord::Base
+      #     has_many :taggings
+      #     has_many :tags, through: :taggings
+      #   end
       #
-      #   [:singularized, :pluralized]
+      #   tags_reflection = Post.reflect_on_association(:tags)
+      #   tags_reflection.source_reflection_names
+      #   # => [:tag, :tags]
       #
       def source_reflection_names
-        @source_reflection_names ||= (options[:source] ? [options[:source]] : [name.to_s.singularize, name]).collect { |n| n.to_sym }
+        options[:source] ? [options[:source]] : [name.to_s.singularize, name].uniq
+      end
+
+      def source_reflection_name # :nodoc:
+        return @source_reflection_name if @source_reflection_name
+
+        names = [name.to_s.singularize, name].collect(&:to_sym).uniq
+        names = names.find_all { |n|
+          through_reflection.klass._reflect_on_association(n)
+        }
+
+        if names.length > 1
+          example_options = options.dup
+          example_options[:source] = source_reflection_names.first
+          ActiveSupport::Deprecation.warn \
+            "Ambiguous source reflection for through association. Please " \
+            "specify a :source directive on your declaration like:\n" \
+            "\n" \
+            "  class #{active_record.name} < ActiveRecord::Base\n" \
+            "    #{macro} :#{name}, #{example_options}\n" \
+            "  end"
+        end
+
+        @source_reflection_name = names.first
       end
 
       def source_options
@@ -496,39 +893,168 @@ module ActiveRecord
         through_reflection.options
       end
 
+      def join_id_for(owner) # :nodoc:
+        source_reflection.join_id_for(owner)
+      end
+
       def check_validity!
         if through_reflection.nil?
           raise HasManyThroughAssociationNotFoundError.new(active_record.name, self)
         end
 
-        if through_reflection.options[:polymorphic]
-          raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
+        if through_reflection.polymorphic?
+          if has_one?
+            raise HasOneAssociationPolymorphicThroughError.new(active_record.name, self)
+          else
+            raise HasManyThroughAssociationPolymorphicThroughError.new(active_record.name, self)
+          end
         end
 
         if source_reflection.nil?
           raise HasManyThroughSourceAssociationNotFoundError.new(self)
         end
 
-        if options[:source_type] && source_reflection.options[:polymorphic].nil?
+        if options[:source_type] && !source_reflection.polymorphic?
           raise HasManyThroughAssociationPointlessSourceTypeError.new(active_record.name, self, source_reflection)
         end
 
-        if source_reflection.options[:polymorphic] && options[:source_type].nil?
+        if source_reflection.polymorphic? && options[:source_type].nil?
           raise HasManyThroughAssociationPolymorphicSourceError.new(active_record.name, self, source_reflection)
         end
 
-        if macro == :has_one && through_reflection.collection?
+        if has_one? && through_reflection.collection?
           raise HasOneThroughCantAssociateThroughCollection.new(active_record.name, self, through_reflection)
         end
 
         check_validity_of_inverse!
       end
 
+      def constraints
+        scope_chain = source_reflection.constraints
+        scope_chain << scope if scope
+        scope_chain
+      end
+
+      def add_as_source(seed)
+        collect_join_reflections seed
+      end
+
+      def add_as_polymorphic_through(reflection, seed)
+        collect_join_reflections(seed + [PolymorphicReflection.new(self, reflection)])
+      end
+
+      def add_as_through(seed)
+        collect_join_reflections(seed + [self])
+      end
+
+      def collect_join_reflections(seed)
+        a = source_reflection.add_as_source seed
+        if options[:source_type]
+          through_reflection.add_as_polymorphic_through self, a
+        else
+          through_reflection.add_as_through a
+        end
+      end
+
+      protected
+
+        def actual_source_reflection # FIXME: this is a horrible name
+          source_reflection.send(:actual_source_reflection)
+        end
+
+        def primary_key(klass)
+          klass.primary_key || raise(UnknownPrimaryKey.new(klass))
+        end
+
+        def inverse_name; delegate_reflection.send(:inverse_name); end
+
       private
         def derive_class_name
           # get the class_name of the belongs_to association of the through reflection
           options[:source_type] || source_reflection.class_name
         end
+
+        delegate_methods = AssociationReflection.public_instance_methods -
+          public_instance_methods
+
+        delegate(*delegate_methods, to: :delegate_reflection)
+
+    end
+
+    class PolymorphicReflection < ThroughReflection # :nodoc:
+      def initialize(reflection, previous_reflection)
+        @reflection = reflection
+        @previous_reflection = previous_reflection
+      end
+
+      def klass
+        @reflection.klass
+      end
+
+      def scope
+        @reflection.scope
+      end
+
+      def table_name
+        @reflection.table_name
+      end
+
+      def plural_name
+        @reflection.plural_name
+      end
+
+      def join_keys(association_klass)
+        @reflection.join_keys(association_klass)
+      end
+
+      def type
+        @reflection.type
+      end
+
+      def constraints
+        @reflection.constraints + [source_type_info]
+      end
+
+      def source_type_info
+        type = @previous_reflection.foreign_type
+        source_type = @previous_reflection.options[:source_type]
+        lambda { |object| where(type => source_type) }
+      end
+    end
+
+    class RuntimeReflection < PolymorphicReflection # :nodoc:
+      attr_accessor :next
+
+      def initialize(reflection, association)
+        @reflection = reflection
+        @association = association
+      end
+
+      def klass
+        @association.klass
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def constraints
+        @reflection.constraints
+      end
+
+      def source_type_info
+        @reflection.source_type_info
+      end
+
+      def alias_candidate(name)
+        "#{plural_name}_#{name}_join"
+      end
+
+      def alias_name
+        Arel::Table.new(table_name)
+      end
+
+      def all_includes; yield; end
     end
   end
 end