module Polyamorous::JoinAssociationExtensions

Public Class Methods

new(reflection, children, polymorphic_class = nil, join_type = Arel::Nodes::InnerJoin) click to toggle source
Calls superclass method
# File lib/polyamorous/activerecord/join_association.rb, line 8
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
prepended(base) click to toggle source
# File lib/polyamorous/activerecord/join_association.rb, line 4
def self.prepended(base)
  base.class_eval { attr_reader :join_type }
end

Public Instance Methods

join_constraints_with_tables(foreign_table, foreign_klass, join_type, alias_tracker, tables) click to toggle source

Same as join_constraints, but instead of constructing tables from the given block, uses the ones passed

# File lib/polyamorous/activerecord/join_association.rb, line 22
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