Merge branch 'master' into nested_has_many_through

Conflicts:
	activerecord/CHANGELOG
	activerecord/lib/active_record/associations.rb

1 files changed, 8 insertions, 552 deletions

diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb
index e82cbd0aa6..fe22fa7ca2 100644
--- a/activerecord/lib/active_record/associations.rb
+++ b/activerecord/lib/active_record/associations.rb
@@ -4,6 +4,8 @@ require 'active_support/core_ext/module/delegation'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/string/conversions'
 require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/class/attribute'
+require 'active_record/associations/class_methods/join_dependency'
 
 module ActiveRecord
   class InverseOfAssociationNotFoundError < ActiveRecordError #:nodoc:
@@ -1853,12 +1855,12 @@ module ActiveRecord
           callbacks.each do |callback_name|
             full_callback_name = "#{callback_name}_for_#{association_name}"
             defined_callbacks = options[callback_name.to_sym]
-            if options.has_key?(callback_name.to_sym)
-              class_inheritable_reader full_callback_name.to_sym
-              write_inheritable_attribute(full_callback_name.to_sym, [defined_callbacks].flatten)
-            else
-              write_inheritable_attribute(full_callback_name.to_sym, [])
-            end
+
+            full_callback_value = options.has_key?(callback_name.to_sym) ? [defined_callbacks].flatten : []
+
+            # TODO : why do i need method_defined? I think its because of the inheritance chain
+            class_attribute full_callback_name.to_sym unless method_defined?(full_callback_name)
+            self.send("#{full_callback_name}=", full_callback_value)
           end
         end
 
@@ -1874,552 +1876,6 @@ module ActiveRecord
             Array.wrap(extensions)
           end
         end
-
-        class JoinDependency # :nodoc:
-          attr_reader :join_parts, :reflections, :alias_tracker
-
-          def initialize(base, associations, joins)
-            @join_parts            = [JoinBase.new(base, joins)]
-            @associations          = {}
-            @reflections           = []
-            @alias_tracker         = AliasTracker.new(joins)
-            @alias_tracker.aliased_name_for(base.table_name) # Updates the count for base.table_name to 1
-            build(associations)
-          end
-
-          def graft(*associations)
-            associations.each do |association|
-              join_associations.detect {|a| association == a} ||
-              build(association.reflection.name, association.find_parent_in(self) || join_base, association.join_type)
-            end
-            self
-          end
-
-          def join_associations
-            join_parts.last(join_parts.length - 1)
-          end
-
-          def join_base
-            join_parts.first
-          end
-
-          def instantiate(rows)
-            primary_key = join_base.aliased_primary_key
-            parents = {}
-
-            records = rows.map { |model|
-              primary_id = model[primary_key]
-              parent = parents[primary_id] ||= join_base.instantiate(model)
-              construct(parent, @associations, join_associations.dup, model)
-              parent
-            }.uniq
-
-            remove_duplicate_results!(join_base.active_record, records, @associations)
-            records
-          end
-
-          def remove_duplicate_results!(base, records, associations)
-            case associations
-              when Symbol, String
-                reflection = base.reflections[associations]
-                remove_uniq_by_reflection(reflection, records)
-              when Array
-                associations.each do |association|
-                  remove_duplicate_results!(base, records, association)
-                end
-              when Hash
-                associations.keys.each do |name|
-                  reflection = base.reflections[name]
-                  remove_uniq_by_reflection(reflection, records)
-
-                  parent_records = []
-                  records.each do |record|
-                    if descendant = record.send(reflection.name)
-                      if reflection.collection?
-                        parent_records.concat descendant.target.uniq
-                      else
-                        parent_records << descendant
-                      end
-                    end
-                  end
-
-                  remove_duplicate_results!(reflection.klass, parent_records, associations[name]) unless parent_records.empty?
-                end
-            end
-          end
-
-          protected
-
-            def cache_joined_association(association)
-              associations = []
-              parent = association.parent
-              while parent != join_base
-                associations.unshift(parent.reflection.name)
-                parent = parent.parent
-              end
-              ref = @associations
-              associations.each do |key|
-                ref = ref[key]
-              end
-              ref[association.reflection.name] ||= {}
-            end
-
-            def build(associations, parent = nil, join_type = Arel::InnerJoin)
-              parent ||= join_parts.last
-              case associations
-                when Symbol, String
-                  reflection = parent.reflections[associations.to_s.intern] or
-                  raise ConfigurationError, "Association named '#{ associations }' was not found; perhaps you misspelled it?"
-                  unless join_association = find_join_association(reflection, parent)
-                    @reflections << reflection
-                    join_association = build_join_association(reflection, parent)
-                    join_association.join_type = join_type
-                    @join_parts << join_association
-                    cache_joined_association(join_association)
-                  end
-                  join_association
-                when Array
-                  associations.each do |association|
-                    build(association, parent, join_type)
-                  end
-                when Hash
-                  associations.keys.sort{|a,b|a.to_s<=>b.to_s}.each do |name|
-                    join_association = build(name, parent, join_type)
-                    build(associations[name], join_association, join_type)
-                  end
-                else
-                  raise ConfigurationError, associations.inspect
-              end
-            end
-
-            def find_join_association(name_or_reflection, parent)
-              if String === name_or_reflection
-                name_or_reflection = name_or_reflection.to_sym
-              end
-
-              join_associations.detect { |j|
-                j.reflection == name_or_reflection && j.parent == parent
-              }
-            end
-
-            def remove_uniq_by_reflection(reflection, records)
-              if reflection && reflection.collection?
-                records.each { |record| record.send(reflection.name).target.uniq! }
-              end
-            end
-
-            def build_join_association(reflection, parent)
-              JoinAssociation.new(reflection, self, parent)
-            end
-
-            def construct(parent, associations, join_parts, row)
-              case associations
-              when Symbol, String
-                name = associations.to_s
-
-                join_part = join_parts.detect { |j|
-                  j.reflection.name.to_s == name &&
-                  j.parent_table_name    == parent.class.table_name }
-
-                raise(ConfigurationError, "No such association") unless join_part
-
-                join_parts.delete(join_part)
-                construct_association(parent, join_part, row)
-              when Array
-                associations.each do |association|
-                  construct(parent, association, join_parts, row)
-                end
-              when Hash
-                associations.sort_by { |k,_| k.to_s }.each do |name, assoc|
-                  association = construct(parent, name, join_parts, row)
-                  construct(association, assoc, join_parts, row) if association
-                end
-              else
-                raise ConfigurationError, associations.inspect
-              end
-            end
-
-            def construct_association(record, join_part, row)
-              return if record.id.to_s != join_part.parent.record_id(row).to_s
-
-              macro = join_part.reflection.macro
-              if macro == :has_one
-                return if record.instance_variable_defined?("@#{join_part.reflection.name}")
-                association = join_part.instantiate(row) unless row[join_part.aliased_primary_key].nil?
-                set_target_and_inverse(join_part, association, record)
-              else
-                return if row[join_part.aliased_primary_key].nil?
-                association = join_part.instantiate(row)
-                case macro
-                when :has_many, :has_and_belongs_to_many
-                  collection = record.send(join_part.reflection.name)
-                  collection.loaded
-                  collection.target.push(association)
-                  collection.__send__(:set_inverse_instance, association, record)
-                when :belongs_to
-                  set_target_and_inverse(join_part, association, record)
-                else
-                  raise ConfigurationError, "unknown macro: #{join_part.reflection.macro}"
-                end
-              end
-              association
-            end
-
-            def set_target_and_inverse(join_part, association, record)
-              association_proxy = record.send("set_#{join_part.reflection.name}_target", association)
-              association_proxy.__send__(:set_inverse_instance, association, record)
-            end
-
-          # A JoinPart represents a part of a JoinDependency. It is an abstract class, inherited
-          # by JoinBase and JoinAssociation. A JoinBase represents the Active Record which
-          # everything else is being joined onto. A JoinAssociation represents an association which
-          # is joining to the base. A JoinAssociation may result in more than one actual join
-          # operations (for example a has_and_belongs_to_many JoinAssociation would result in
-          # two; one for the join table and one for the target table).
-          class JoinPart # :nodoc:
-            # The Active Record class which this join part is associated 'about'; for a JoinBase
-            # this is the actual base model, for a JoinAssociation this is the target model of the
-            # association.
-            attr_reader :active_record
-
-            delegate :table_name, :column_names, :primary_key, :reflections, :sanitize_sql, :arel_engine, :to => :active_record
-
-            def initialize(active_record)
-              @active_record = active_record
-              @cached_record = {}
-            end
-
-            def ==(other)
-              raise NotImplementedError
-            end
-
-            # An Arel::Table for the active_record
-            def table
-              raise NotImplementedError
-            end
-
-            # The prefix to be used when aliasing columns in the active_record's table
-            def aliased_prefix
-              raise NotImplementedError
-            end
-
-            # The alias for the active_record's table
-            def aliased_table_name
-              raise NotImplementedError
-            end
-
-            # The alias for the primary key of the active_record's table
-            def aliased_primary_key
-              "#{aliased_prefix}_r0"
-            end
-
-            # An array of [column_name, alias] pairs for the table
-            def column_names_with_alias
-              unless defined?(@column_names_with_alias)
-                @column_names_with_alias = []
-
-                ([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
-                  @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
-                end
-              end
-
-              @column_names_with_alias
-            end
-
-            def extract_record(row)
-              Hash[column_names_with_alias.map{|cn, an| [cn, row[an]]}]
-            end
-
-            def record_id(row)
-              row[aliased_primary_key]
-            end
-
-            def instantiate(row)
-              @cached_record[record_id(row)] ||= active_record.send(:instantiate, extract_record(row))
-            end
-          end
-
-          class JoinBase < JoinPart # :nodoc:
-            # Extra joins provided when the JoinDependency was created
-            attr_reader :table_joins
-
-            def initialize(active_record, joins = nil)
-              super(active_record)
-              @table_joins = joins
-            end
-
-            def ==(other)
-              other.class == self.class &&
-              other.active_record == active_record
-            end
-
-            def aliased_prefix
-              "t0"
-            end
-
-            def table
-              Arel::Table.new(table_name, :engine => arel_engine, :columns => active_record.columns)
-            end
-
-            def aliased_table_name
-              active_record.table_name
-            end
-          end
-
-          class JoinAssociation < JoinPart # :nodoc:
-            # The reflection of the association represented
-            attr_reader :reflection
-
-            # The JoinDependency object which this JoinAssociation exists within. This is mainly
-            # relevant for generating aliases which do not conflict with other joins which are
-            # part of the query.
-            attr_reader :join_dependency
-
-            # A JoinBase instance representing the active record we are joining onto.
-            # (So in Author.has_many :posts, the Author would be that base record.)
-            attr_reader :parent
-
-            # What type of join will be generated, either Arel::InnerJoin (default) or Arel::OuterJoin
-            attr_accessor :join_type
-
-            attr_reader :aliased_prefix
-
-            delegate :options, :through_reflection, :source_reflection, :through_reflection_chain, :to => :reflection
-            delegate :table, :table_name, :to => :parent, :prefix => true
-            delegate :alias_tracker, :to => :join_dependency
-
-            def initialize(reflection, join_dependency, parent = nil)
-              reflection.check_validity!
-
-              if reflection.options[:polymorphic]
-                raise EagerLoadPolymorphicError.new(reflection)
-              end
-
-              super(reflection.klass)
-
-              @reflection         = reflection
-              @join_dependency    = join_dependency
-              @parent             = parent
-              @join_type          = Arel::InnerJoin
-              @aliased_prefix     = "t#{ join_dependency.join_parts.size }"
-
-              setup_tables
-            end
-
-            def ==(other)
-              other.class == self.class &&
-              other.reflection == reflection &&
-              other.parent == parent
-            end
-
-            def find_parent_in(other_join_dependency)
-              other_join_dependency.join_parts.detect do |join_part|
-                self.parent == join_part
-              end
-            end
-
-            def join_to(relation)
-              # The chain starts with the target table, but we want to end with it here (makes
-              # more sense in this context)
-              chain = through_reflection_chain.reverse
-
-              foreign_table = parent_table
-              index = 0
-
-              chain.each do |reflection|
-                table = @tables[index]
-                conditions = []
-
-                if reflection.source_reflection.nil?
-                  case reflection.macro
-                    when :belongs_to
-                      key         = reflection.association_primary_key
-                      foreign_key = reflection.primary_key_name
-                    when :has_many, :has_one
-                      key         = reflection.primary_key_name
-                      foreign_key = reflection.active_record_primary_key
-
-                      conditions << polymorphic_conditions(reflection, table)
-                    when :has_and_belongs_to_many
-                      # For habtm, we need to deal with the join table at the same time as the
-                      # target table (because unlike a :through association, there is no reflection
-                      # to represent the join table)
-                      table, join_table = table
-
-                      join_key         = reflection.primary_key_name
-                      join_foreign_key = reflection.active_record.primary_key
-
-                      relation = relation.join(join_table, join_type).on(
-                        join_table[join_key].
-                          eq(foreign_table[join_foreign_key])
-                      )
-
-                      # We've done the first join now, so update the foreign_table for the second
-                      foreign_table = join_table
-
-                      key         = reflection.klass.primary_key
-                      foreign_key = reflection.association_foreign_key
-                  end
-                else
-                  case reflection.source_reflection.macro
-                    when :belongs_to
-                      key         = reflection.association_primary_key
-                      foreign_key = reflection.primary_key_name
-
-                      conditions << source_type_conditions(reflection, foreign_table)
-                    when :has_many, :has_one
-                      key         = reflection.primary_key_name
-                      foreign_key = reflection.source_reflection.active_record_primary_key
-                    when :has_and_belongs_to_many
-                      table, join_table = table
-
-                      join_key         = reflection.primary_key_name
-                      join_foreign_key = reflection.klass.primary_key
-
-                      relation = relation.join(join_table, join_type).on(
-                        join_table[join_key].
-                          eq(foreign_table[join_foreign_key])
-                      )
-
-                      foreign_table = join_table
-
-                      key         = reflection.klass.primary_key
-                      foreign_key = reflection.association_foreign_key
-                  end
-                end
-
-                conditions << table[key].eq(foreign_table[foreign_key])
-
-                conditions << reflection_conditions(index, table)
-                conditions << sti_conditions(reflection, table)
-
-                relation = relation.join(table, join_type).on(*conditions.flatten.compact)
-
-                # The current table in this iteration becomes the foreign table in the next
-                foreign_table = table
-                index += 1
-              end
-
-              relation
-            end
-
-            def join_relation(joining_relation)
-              self.join_type = Arel::OuterJoin
-              joining_relation.joins(self)
-            end
-
-            def table
-              if @tables.last.is_a?(Array)
-                @tables.last.first
-              else
-                @tables.last
-              end
-            end
-
-            def aliased_table_name
-              table.table_alias || table.name
-            end
-
-            protected
-
-              def table_alias_for(reflection, join = false)
-                name = alias_tracker.pluralize(reflection.name)
-                name << "_#{parent_table_name}"
-                name << "_join" if join
-                name
-              end
-
-              def interpolate_sql(sql)
-                instance_eval("%@#{sql.gsub('@', '\@')}@", __FILE__, __LINE__)
-              end
-
-            private
-
-            # Generate aliases and Arel::Table instances for each of the tables which we will
-            # later generate joins for. We must do this in advance in order to correctly allocate
-            # the proper alias.
-            def setup_tables
-              @tables = through_reflection_chain.map do |reflection|
-                aliased_table_name = alias_tracker.aliased_name_for(
-                  reflection.table_name,
-                  table_alias_for(reflection, reflection != self.reflection)
-                )
-
-                table = Arel::Table.new(
-                  reflection.table_name, :engine => arel_engine,
-                  :as => aliased_table_name, :columns => reflection.klass.columns
-                )
-
-                # For habtm, we have two Arel::Table instances related to a single reflection, so
-                # we just store them as a pair in the array.
-                if reflection.macro == :has_and_belongs_to_many ||
-                     (reflection.source_reflection &&
-                      reflection.source_reflection.macro == :has_and_belongs_to_many)
-
-                  join_table_name = (reflection.source_reflection || reflection).options[:join_table]
-
-                  aliased_join_table_name = alias_tracker.aliased_name_for(
-                    join_table_name,
-                    table_alias_for(reflection, true)
-                  )
-
-                  join_table = Arel::Table.new(
-                    join_table_name, :engine => arel_engine,
-                    :as => aliased_join_table_name
-                  )
-
-                  [table, join_table]
-                else
-                  table
-                end
-              end
-
-              # The joins are generated from the through_reflection_chain in reverse order, so
-              # reverse the tables too (but it's important to generate the aliases in the 'forward'
-              # order, which is why we only do the reversal now.
-              @tables.reverse!
-
-              @tables
-            end
-
-            def reflection_conditions(index, table)
-              @reflection.through_conditions.reverse[index].map do |condition|
-                Arel.sql(interpolate_sql(sanitize_sql(
-                  condition,
-                  table.table_alias || table.name
-                )))
-              end
-            end
-
-            def sti_conditions(reflection, table)
-              unless reflection.klass.descends_from_active_record?
-                sti_column = table[reflection.klass.inheritance_column]
-
-                condition = sti_column.eq(reflection.klass.sti_name)
-
-                reflection.klass.descendants.each do |subclass|
-                  condition = condition.or(sti_column.eq(subclass.sti_name))
-                end
-
-                condition
-              end
-            end
-
-            def source_type_conditions(reflection, foreign_table)
-              if reflection.options[:source_type]
-                foreign_table[reflection.source_reflection.options[:foreign_type]].
-                  eq(reflection.options[:source_type])
-              end
-           end
-
-           def polymorphic_conditions(reflection, table)
-             if reflection.options[:as]
-               table["#{reflection.options[:as]}_type"].
-                 eq(reflection.active_record.base_class.name)
-             end
-           end
-        end
-      end
     end
   end
 end