class ActiveRecord::Reflection::MacroReflection

AggregateReflection and AssociationReflection are returned by the Reflection::ClassMethods.
Base class for AggregateReflection and AssociationReflection. Objects of

def ==(other_aggregation)

and +other_aggregation+ has an options hash assigned to it.
Returns +true+ if +self+ and +other_aggregation+ have the same +name+ attribute, +active_record+ attribute, 
def ==(other_aggregation)
  super ||
    other_aggregation.kind_of?(self.class) &&
    name == other_aggregation.name &&
    !other_aggregation.options.nil? &&
    active_record == other_aggregation.active_record
end

def _klass(class_name) # :nodoc:

:nodoc: 
def _klass(class_name) # :nodoc:
  if active_record.name.demodulize == class_name
    return compute_class("::#{class_name}") rescue NameError
  end
  compute_class(class_name)
end

def autosave=(autosave) 

def autosave=(autosave)
  @options[:autosave] = autosave
  parent_reflection = self.parent_reflection
  if parent_reflection
    parent_reflection.autosave = autosave
  end
end

def compute_class(name) 

def compute_class(name)
  name.constantize
end

def derive_class_name 

def derive_class_name
  name.to_s.camelize
end

def initialize(name, scope, options, active_record) 

def initialize(name, scope, options, active_record)
  super()
  @name          = name
  @scope         = scope
  @options       = normalize_options(options)
  @active_record = active_record
  @klass         = options[:anonymous_class]
  @plural_name   = active_record.pluralize_table_names ?
                      name.to_s.pluralize : name.to_s
end

def klass

instead. This allows plugins to hook into association object creation.
a new association object. Use +build_association+ or +create_association+
Note: Do not call +klass.new+ or +klass.create+ to instantiate

# => Client
Company.reflect_on_association(:clients).klass

end
has_many :clients
class Company < ActiveRecord::Base

has_many :clients returns the Client class
composed_of :balance, class_name: 'Money' returns the Money class

Returns the class for the macro. 
def klass
  @klass ||= _klass(class_name)
end

def normalize_options(options) 

def normalize_options(options)
  counter_cache = options.delete(:counter_cache)
  if counter_cache
    active = true
    case counter_cache
    when String, Symbol
      column = -counter_cache.to_s
    when Hash
      active = counter_cache.fetch(:active, true)
      column = counter_cache[:column]&.to_s
    end
    options[:counter_cache] = { active: active, column: column }
  end
  options
end

def scope_for(relation, owner = nil) 

def scope_for(relation, owner = nil)
  relation.instance_exec(owner, &scope) || relation
end