module ActiveRecord::AutosaveAssociation

def associated_records_to_validate_or_save(association, new_record, autosave)
  if new_record
    association
  elsif autosave
    association.target.find_all { |record| record.changed_for_autosave? }
  else
    association.target.find_all { |record| record.new_record? }
  end
end

def association_valid?(reflection, association)
  return true if association.destroyed? || association.marked_for_destruction?
  unless valid = association.valid?
    if reflection.options[:autosave]
      association.errors.each do |attribute, message|
        attribute = "#{reflection.name}.#{attribute}"
        errors[attribute] << message
        errors[attribute].uniq!
      end
    else
      errors.add(reflection.name)
    end
  end
  valid
end

def before_save_collection_association
  @new_record_before_save = new_record?
  true
end

def changed_for_autosave?
  new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave?
end

def mark_for_destruction
  @marked_for_destruction = true
end

def marked_for_destruction?
  @marked_for_destruction
end

def nested_records_changed_for_autosave?
  self.class.reflect_on_all_autosave_associations.any? do |reflection|
    association = association_instance_get(reflection.name)
    association && Array.wrap(association.target).any? { |a| a.changed_for_autosave? }
  end
end

def reload(options = nil)
  @marked_for_destruction = false
  super
end

def save_belongs_to_association(reflection)
  if (association = association_instance_get(reflection.name)) && !association.destroyed?
    autosave = reflection.options[:autosave]
    if autosave && association.marked_for_destruction?
      association.destroy
    elsif autosave != false
      saved = association.save(:validate => !autosave) if association.new_record? || autosave
      if association.updated?
        association_id = association.send(reflection.options[:primary_key] || :id)
        self[reflection.primary_key_name] = association_id
      end
      saved if autosave
    end
  end
end

def save_collection_association(reflection)
  if association = association_instance_get(reflection.name)
    autosave = reflection.options[:autosave]
    if records = associated_records_to_validate_or_save(association, @new_record_before_save, autosave)
      records.each do |record|
        next if record.destroyed?
        if autosave && record.marked_for_destruction?
          association.destroy(record)
        elsif autosave != false && (@new_record_before_save || record.new_record?)
          if autosave
            saved = association.send(:insert_record, record, false, false)
          else
            association.send(:insert_record, record)
          end
        elsif autosave
          saved = record.save(:validate => false)
        end
        raise ActiveRecord::Rollback if saved == false
      end
    end
    # reconstruct the SQL queries now that we know the owner's id
    association.send(:construct_sql) if association.respond_to?(:construct_sql)
  end
end

def save_has_one_association(reflection)
  if (association = association_instance_get(reflection.name)) && !association.target.nil? && !association.destroyed?
    autosave = reflection.options[:autosave]
    if autosave && association.marked_for_destruction?
      association.destroy
    else
      key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
      if autosave != false && (new_record? || association.new_record? || association[reflection.primary_key_name] != key || autosave)
        association[reflection.primary_key_name] = key
        saved = association.save(:validate => !autosave)
        raise ActiveRecord::Rollback if !saved && autosave
        saved
      end
    end
  end
end

def validate_collection_association(reflection)
  if association = association_instance_get(reflection.name)
    if records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave])
      records.each { |record| association_valid?(reflection, record) }
    end
  end
end

def validate_single_association(reflection)
  if (association = association_instance_get(reflection.name)) && !association.target.nil?
    association_valid?(reflection, association)
  end
end