class Quickery::AssociationChain

Attributes

belongs_to[R]
child_association_chain[R]
dependee_column_name[R]
model[R]
name[R]
parent_association_chain[R]
quickery_builder[RW]

Public Class Methods

new(model:, parent_association_chain: nil, name: nil) click to toggle source
# File lib/quickery/association_chain.rb, line 11
def initialize(model:, parent_association_chain: nil, name: nil)
  @model = model
  @parent_association_chain = parent_association_chain
  @name = name
end

Public Instance Methods

build_children_association_chains(names_left:) click to toggle source
# File lib/quickery/association_chain.rb, line 17
def build_children_association_chains(names_left:)
  current_name = names_left.first

  reflections = @model.reflections
  column_names = @model.column_names
  belongs_to_association_names = reflections.map{ |key, value| value.macro == :belongs_to ? key : nil }.compact

  if belongs_to_association_names.include? current_name
    @belongs_to = reflections[current_name]
    @child_association_chain = AssociationChain.new(
      model: belongs_to.class_name.constantize,
      parent_association_chain: self,
      name: current_name,
    )
    @child_association_chain.build_children_association_chains(names_left: names_left[1..-1])
    return self

  elsif column_names.include? current_name
    @dependee_column_name = current_name
    return self

  else
    raise Quickery::Errors::InvalidAssociationOrAttributeError.new(current_name)
  end
end
child_association_chains(include_self: false, association_chains: []) click to toggle source
# File lib/quickery/association_chain.rb, line 43
def child_association_chains(include_self: false, association_chains: [])
  association_chains << self if include_self

  if @child_association_chain.nil?
    association_chains
  else
    association_chains << @child_association_chain
    return @child_association_chain.child_association_chains(association_chains: association_chains)
  end
end
dependee_record(from_record) click to toggle source
# File lib/quickery/association_chain.rb, line 77
def dependee_record(from_record)
  raise ArgumentError, 'argument should be an instance of @model' unless from_record.is_a? model

  child_association_chains(include_self: true).inject(from_record) do |from_record, association_chain|
    if association_chain.belongs_to
      from_record.send(association_chain.belongs_to.name) if from_record
    else
      from_record
    end
  end
end
dependent_records(from_record) click to toggle source
# File lib/quickery/association_chain.rb, line 89
def dependent_records(from_record)
  primary_key_value = from_record.send(from_record.class.primary_key)
  most_parent_model = parent_association_chains.last.model

  records = most_parent_model.all

  unless (joins_arg_tmp = joins_arg).nil?
    records = records.joins(joins_arg_tmp)
  end

  records = records.where(
    model.table_name => {
      model.primary_key => primary_key_value
    }
  )
end
joins_arg(current_joins_arg = nil) click to toggle source
# File lib/quickery/association_chain.rb, line 65
def joins_arg(current_joins_arg = nil)
  if @parent_association_chain.nil?
    current_joins_arg
  else
    if current_joins_arg.nil?
      @parent_association_chain.joins_arg(@name.to_sym)
    else
      @parent_association_chain.joins_arg({ @name.to_sym => current_joins_arg })
    end
  end
end
parent_association_chains(include_self: false, association_chains: []) click to toggle source
# File lib/quickery/association_chain.rb, line 54
def parent_association_chains(include_self: false, association_chains: [])
  association_chains << self if include_self

  if @parent_association_chain.nil?
    association_chains
  else
    association_chains << @parent_association_chain
    @parent_association_chain.parent_association_chains(association_chains: association_chains)
  end
end