module ActiveRecord::Reflection::ClassMethods

def _reflect_on_association(association) # :nodoc:

:nodoc: 
def _reflect_on_association(association) # :nodoc:
  _reflections[association.to_s]
end

def clear_reflections_cache # :nodoc:

:nodoc: 
def clear_reflections_cache # :nodoc:
  @__reflections = nil
end

def reflect_on_aggregation(aggregation)


Account.reflect_on_aggregation(:balance) # => the balance AggregateReflection

Returns the AggregateReflection object for the named +aggregation+ (use the symbol). 
def reflect_on_aggregation(aggregation)
  aggregate_reflections[aggregation.to_s]
end

def reflect_on_all_aggregations

Returns an array of AggregateReflection objects for all the aggregations in the class. 
def reflect_on_all_aggregations
  aggregate_reflections.values
end

def reflect_on_all_associations(macro = nil)


Account.reflect_on_all_associations(:has_many) # returns an array of all has_many associations
Account.reflect_on_all_associations # returns an array of all associations

Example:

:belongs_to) as the first parameter.
association type, pass in the symbol (:has_many, :has_one,
associations in the class. If you only want to reflect on a certain
Returns an array of AssociationReflection objects for all the 
def reflect_on_all_associations(macro = nil)
  association_reflections = reflections.values
  association_reflections.select! { |reflection| reflection.macro == macro } if macro
  association_reflections
end

def reflect_on_all_autosave_associations

Returns an array of AssociationReflection objects for all associations which have :autosave enabled. 
def reflect_on_all_autosave_associations
  reflections.values.select { |reflection| reflection.options[:autosave] }
end

def reflect_on_association(association)


Invoice.reflect_on_association(:line_items).macro # returns :has_many
Account.reflect_on_association(:owner) # returns the owner AssociationReflection

Returns the AssociationReflection object for the +association+ (use the symbol). 
def reflect_on_association(association)
  reflections[association.to_s]
end

def reflections


Account.reflections # => {"balance" => AggregateReflection}

Returns a Hash of name of the reflection as the key and an AssociationReflection as the value. 
def reflections
  @__reflections ||= begin
    ref = {}
    _reflections.each do |name, reflection|
      parent_reflection = reflection.parent_reflection
      if parent_reflection
        parent_name = parent_reflection.name
        ref[parent_name.to_s] = parent_reflection
      else
        ref[name] = reflection
      end
    end
    ref
  end
end