module ActiveRecord::AutosaveAssociation::ClassMethods

def add_autosave_association_callbacks(reflection)

before actually defining them.
check if the save or validation methods have already been defined
the callbacks to get defined multiple times, there are guards that
called _after_ the association has been defined. Since we don't want
this can change, for instance, when using nested attributes, which is
get created when they are invoked for the very first time. However,
However the validation and callback methods are lazy and those methods
For performance reasons, we don't check whether to validate at runtime.

the +reflection+.
Adds validation and save callbacks for the association as specified by 
def add_autosave_association_callbacks(reflection)
  save_method = :"autosave_associated_records_for_#{reflection.name}"
  if reflection.collection?
    around_save :around_save_collection_association
    define_non_cyclic_method(save_method) { save_collection_association(reflection) }
    # Doesn't use after_save as that would save associations added in after_create/after_update twice
    after_create save_method
    after_update save_method
  elsif reflection.has_one?
    define_non_cyclic_method(save_method) { save_has_one_association(reflection) }
    # Configures two callbacks instead of a single after_save so that
    # the model may rely on their execution order relative to its
    # own callbacks.
    #
    # For example, given that after_creates run before after_saves, if
    # we configured instead an after_save there would be no way to fire
    # a custom after_create callback after the child association gets
    # created.
    after_create save_method
    after_update save_method
  else
    define_non_cyclic_method(save_method) { throw(:abort) if save_belongs_to_association(reflection) == false }
    before_save save_method
  end
  define_autosave_validation_callbacks(reflection)
end

def define_autosave_validation_callbacks(reflection) 

def define_autosave_validation_callbacks(reflection)
  validation_method = :"validate_associated_records_for_#{reflection.name}"
  if reflection.validate? && !method_defined?(validation_method)
    if reflection.collection?
      method = :validate_collection_association
    else
      method = :validate_single_association
    end
    define_non_cyclic_method(validation_method) { send(method, reflection) }
    validate validation_method
    after_validation :_ensure_no_duplicate_errors
  end
end

def define_non_cyclic_method(name, &block) 

def define_non_cyclic_method(name, &block)
  return if method_defined?(name, false)
  define_method(name) do |*args|
    result = true; @_already_called ||= {}
    # Loop prevention for validation of associations
    unless @_already_called[name]
      begin
        @_already_called[name] = true
        result = instance_eval(&block)
      ensure
        @_already_called[name] = false
      end
    end
    result
  end
end