module ActiveRecord::Reflection::ClassMethods

def create_reflection(macro, name, options, active_record) 

def create_reflection(macro, name, options, active_record)
  case macro
    when :has_many, :belongs_to, :has_one, :has_and_belongs_to_many
      klass = options[:through] ? ThroughReflection : AssociationReflection
      reflection = klass.new(macro, name, options, active_record)
    when :composed_of
      reflection = AggregateReflection.new(macro, name, options, active_record)
  end
  write_inheritable_hash :reflections, name => reflection
  reflection
end

def reflect_on_aggregation(aggregation)


Account.reflect_on_aggregation(:balance) # returns the balance AggregateReflection

Returns the AggregateReflection object for the named +aggregation+ (use the symbol). Example: 
def reflect_on_aggregation(aggregation)
  reflections[aggregation].is_a?(AggregateReflection) ? reflections[aggregation] : nil
end

def reflect_on_all_aggregations

Returns an array of AggregateReflection objects for all the aggregations in the class. 
def reflect_on_all_aggregations
  reflections.values.select { |reflection| reflection.is_a?(AggregateReflection) }
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:
certain association type, pass in the symbol (:has_many, :has_one, :belongs_to) for that as the first parameter.
Returns an array of AssociationReflection objects for all the associations in the class. If you only want to reflect on a 
def reflect_on_all_associations(macro = nil)
  association_reflections = reflections.values.select { |reflection| reflection.is_a?(AssociationReflection) }
  macro ? association_reflections.select { |reflection| reflection.macro == 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 named +association+ (use the symbol). Example: 
def reflect_on_association(association)
  reflections[association].is_a?(AssociationReflection) ? reflections[association] : nil
end

def reflections


Account.reflections
Invoice.reflections

Example:
Returns a hash containing all AssociationReflection objects for the current class 
def reflections
  read_inheritable_attribute(:reflections) || write_inheritable_attribute(:reflections, {})
end