123456789_123456789_123456789_123456789_123456789_

Class: ActiveRecord::Associations::Preloader::Branch

Do not use. This class is for internal use only.
Relationships & Source Files
Inherits: Object
Defined in: activerecord/lib/active_record/associations/preloader/branch.rb

Class Method Summary

Instance Attribute Summary

Instance Method Summary

Constructor Details

.new(association:, children:, parent:, associate_by_default:, scope:) ⇒ Branch

[ GitHub ] 

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 11



def initialize(association:, children:, parent:, associate_by_default:, scope:)
  @association = association
  @parent = parent
  @scope = scope
  @associate_by_default = associate_by_default

  @children = build_children(children)
  @loaders = nil
end


  







Instance Attribute Details



  

    #associate_by_default   (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 8



attr_reader :scope, :associate_by_default


  








  

    #association   (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 7



attr_reader :association, :children, :parent


  








  

    #children   (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 7



attr_reader :association, :children, :parent


  








  

    #done?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 66



def done?
  root? || (@loaders && @loaders.all?(&:run?))
end


  








  

    #parent   (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 7



attr_reader :association, :children, :parent


  








  

    #polymorphic?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 102



def polymorphic?
  return false if root?
  return @polymorphic if defined?(@polymorphic)

  @polymorphic = source_records.any? do |record|
    reflection = record.class._reflect_on_association(association)
    reflection && reflection.options[:polymorphic]
  end
end


  








  

    #preloaded_records   (rw)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 62



def preloaded_records
  @preloaded_records ||= loaders.flat_map(&:preloaded_records)
end


  








  

    #preloaded_records=(value)   (rw)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 9



attr_writer :preloaded_records


  








  

    #root?  ⇒ Boolean  (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 54



def root?
  parent.nil?
end


  








  

    #scope   (readonly)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 8



attr_reader :scope, :associate_by_default


  







Instance Method Details



  

    #build_children(children)   (private)
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 120



def build_children(children)
  Array.wrap(children).flat_map { |association|
    Array(association).flat_map { |parent, child|
      Branch.new(
        parent: self,
        association: parent,
        children: child,
        associate_by_default: associate_by_default,
        scope: scope
      )
    }
  }
end


  








  

    #future_classes  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 21



def future_classes
  (immediate_future_classes + children.flat_map(&:future_classes)).uniq
end


  








  

    #grouped_records  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 74



def grouped_records
  h = {}
  polymorphic_parent = !root? && parent.polymorphic?
  source_records.each do |record|
    reflection = record.class._reflect_on_association(association)
    next if polymorphic_parent && !reflection || !record.association(association).klass
    (h[reflection] ||= []) << record
  end
  h
end


  








  

    #immediate_future_classes  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 25



def immediate_future_classes
  if parent.done?
    loaders.flat_map(&:future_classes).uniq
  else
    likely_reflections.reject(&:polymorphic?).flat_map do |reflection|
      reflection.
        chain.
        map(&:klass)
    end.uniq
  end
end


  








  

    #likely_reflections  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 47



def likely_reflections
  parent_classes = parent.target_classes
  parent_classes.filter_map do |parent_klass|
    parent_klass._reflect_on_association(@association)
  end
end


  








  

    #loaders  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 112



def loaders
  @loaders ||=
    grouped_records.flat_map do |reflection, reflection_records|
      preloaders_for_reflection(reflection, reflection_records)
    end
end


  








  

    #preloader_for(reflection)   (private)
  



  

    

Returns a class containing the logic needed to load preload the data and attach it to a relation. The class returned implements a run method that accepts a preloader.


  



  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 137



def preloader_for(reflection)
  if reflection.options[:through]
    ThroughAssociation
  else
    Association
  end
end


  








  

    #preloaders_for_reflection(reflection, reflection_records)  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 85



def preloaders_for_reflection(reflection, reflection_records)
  reflection_records.group_by do |record|
    klass = record.association(association).klass

    if reflection.scope && reflection.scope.arity != 0
      # For instance dependent scopes, the scope is potentially
      # different for each record. To allow this we'll group each
      # object separately into its own preloader
      reflection_scope = reflection.join_scopes(klass.arel_table, klass.predicate_builder, klass, record).inject(&:merge!)
    end

    [klass, reflection_scope]
  end.map do |(rhs_klass, reflection_scope), rs|
    preloader_for(reflection).new(rhs_klass, rs, reflection, scope, reflection_scope, associate_by_default)
  end
end


  








  

    #runnable_loaders  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 70



def runnable_loaders
  loaders.flat_map(&:runnable_loaders).reject(&:run?)
end


  








  

    #source_records  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 58



def source_records
  @parent.preloaded_records
end


  








  

    #target_classes  
  

  [ GitHub ]


  

  


# File 'activerecord/lib/active_record/associations/preloader/branch.rb', line 37



def target_classes
  if done?
    preloaded_records.map(&:klass).uniq
  elsif parent.done?
    loaders.map(&:klass).uniq
  else
    likely_reflections.reject(&:polymorphic?).map(&:klass).uniq
  end
end