module Polyamorous::JoinAssociationExtensions

def self.prepended(base)
  base.class_eval { attr_reader :join_type }
end

def initialize(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin)
  @join_type = join_type
  if polymorphic_class && ::ActiveRecord::Base > polymorphic_class
    swapping_reflection_klass(reflection, polymorphic_class) do |reflection|
      super(reflection, children)
      self.reflection.options[:polymorphic] = true
    end
  else
    super(reflection, children)
  end
end

def join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables)
  joins = []
  chain = []
  reflection.chain.each.with_index do |reflection, i|
    table = tables[i]
    @table ||= table
    chain << [reflection, table]
  end
  # The chain starts with the target table, but we want to end with it here (makes
  # more sense in this context), so we reverse
  chain.reverse_each do |reflection, table|
    klass = reflection.klass
    join_scope = reflection.join_scope(table, foreign_table, foreign_klass)
    unless join_scope.references_values.empty?
      join_dependency = join_scope.construct_join_dependency(
        join_scope.eager_load_values | join_scope.includes_values, Arel::Nodes::OuterJoin
      )
      join_scope.joins!(join_dependency)
    end
    arel = join_scope.arel(alias_tracker.aliases)
    nodes = arel.constraints.first
    if nodes.is_a?(Arel::Nodes::And)
      others = nodes.children.extract! do |node|
        !Arel.fetch_attribute(node) { |attr| attr.relation.name == table.name }
      end
    end
    joins << table.create_join(table, table.create_on(nodes), join_type)
    if others && !others.empty?
      joins.concat arel.join_sources
      append_constraints(joins.last, others)
    end
    # The current table in this iteration becomes the foreign table in the next
    foreign_table, foreign_klass = table, klass
  end
  joins
end