module DuckRecord::NestedValidateAssociation

Active Record Autosave Association

AutosaveAssociation is a module that takes care of automatically saving associated records when their parent is saved. In addition to saving, it also destroys any associated records that were marked for destruction. (See mark_for_destruction and marked_for_destruction?).

Saving of the parent, its associations, and the destruction of marked associations, all happen inside a transaction. This should never leave the database in an inconsistent state.

If validations for any of the associations fail, their error messages will be applied to the parent.

Note that it also means that associations marked for destruction won't be destroyed directly. They will however still be marked for destruction.

Note that autosave: false is not same as not declaring :autosave. When the :autosave option is not present then new association records are saved but the updated association records are not saved.

Validation

Child records are validated unless :validate is false.

Callbacks

Association with autosave option defines several callbacks on your model (before_save, after_create, after_update). Please note that callbacks are executed in the order they were defined in model. You should avoid modifying the association content, before autosave callbacks are executed. Placing your callbacks after associations is usually a good practice.

One-to-one Example

class Post < ActiveRecord::Base
  has_one :author, autosave: true
end

Saving changes to the parent and its associated model can now be performed automatically and atomically:

post = Post.find(1)
post.title       # => "The current global position of migrating ducks"
post.author.name # => "alloy"

post.title = "On the migration of ducks"
post.author.name = "Eloy Duran"

post.save
post.reload
post.title       # => "On the migration of ducks"
post.author.name # => "Eloy Duran"

Destroying an associated model, as part of the parent's save action, is as simple as marking it for destruction:

post.author.mark_for_destruction
post.author.marked_for_destruction? # => true

Note that the model is not yet removed from the database:

id = post.author.id
Author.find_by(id: id).nil? # => false

post.save
post.reload.author # => nil

Now it is removed from the database:

Author.find_by(id: id).nil? # => true

One-to-many Example

When :autosave is not declared new children are saved when their parent is saved:

class Post < ActiveRecord::Base
  has_many :comments # :autosave option is not declared
end

post = Post.new(title: 'ruby rocks')
post.comments.build(body: 'hello world')
post.save # => saves both post and comment

post = Post.create(title: 'ruby rocks')
post.comments.build(body: 'hello world')
post.save # => saves both post and comment

post = Post.create(title: 'ruby rocks')
post.comments.create(body: 'hello world')
post.save # => saves both post and comment

When :autosave is true all children are saved, no matter whether they are new records or not:

class Post < ActiveRecord::Base
  has_many :comments, autosave: true
end

post = Post.create(title: 'ruby rocks')
post.comments.create(body: 'hello world')
post.comments[0].body = 'hi everyone'
post.comments.build(body: "good morning.")
post.title += "!"
post.save # => saves both post and comments.

Destroying one of the associated models as part of the parent's save action is as simple as marking it for destruction:

post.comments # => [#<Comment id: 1, ...>, #<Comment id: 2, ...]>
post.comments[1].mark_for_destruction
post.comments[1].marked_for_destruction? # => true
post.comments.length # => 2

Note that the model is not yet removed from the database:

id = post.comments.last.id
Comment.find_by(id: id).nil? # => false

post.save
post.reload.comments.length # => 1

Now it is removed from the database:

Comment.find_by(id: id).nil? # => true

Private Instance Methods

_ensure_no_duplicate_errors() click to toggle source
# File lib/duck_record/nested_validate_association.rb, line 256
def _ensure_no_duplicate_errors
  errors.messages.each_key do |attribute|
    errors[attribute].uniq!
  end
end
association_valid?(reflection, record, index = nil) click to toggle source

Returns whether or not the association is valid and applies any errors to the parent, self, if it wasn't. Skips any :autosave enabled records if they're marked_for_destruction? or destroyed.

# File lib/duck_record/nested_validate_association.rb, line 225
def association_valid?(reflection, record, index = nil)
  unless valid = record.valid?
    indexed_attribute = !index.nil? && (reflection.options[:index_errors] || DuckRecord::Base.index_nested_attribute_errors)

    record.errors.each do |attribute, message|
      attribute = normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
      errors[attribute] << message
      errors[attribute].uniq!
    end

    record.errors.details.each_key do |attribute|
      reflection_attribute =
        normalize_reflection_attribute(indexed_attribute, reflection, index, attribute).to_sym

      record.errors.details[attribute].each do |error|
        errors.details[reflection_attribute] << error
        errors.details[reflection_attribute].uniq!
      end
    end
  end
  valid
end
normalize_reflection_attribute(indexed_attribute, reflection, index, attribute) click to toggle source
# File lib/duck_record/nested_validate_association.rb, line 248
def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute)
  if indexed_attribute
    "#{reflection.name}[#{index}].#{attribute}"
  else
    "#{reflection.name}.#{attribute}"
  end
end
validate_collection_association(reflection) click to toggle source

Validate the associated records if :validate or :autosave is turned on for the association specified by reflection.

# File lib/duck_record/nested_validate_association.rb, line 214
def validate_collection_association(reflection)
  if association = association_instance_get(reflection.name)
    if records = association.target
      records.each_with_index { |record, index| association_valid?(reflection, record, index) }
    end
  end
end
validate_single_association(reflection) click to toggle source

Validate the association if :validate or :autosave is turned on for the association.

# File lib/duck_record/nested_validate_association.rb, line 205
def validate_single_association(reflection)
  association = association_instance_get(reflection.name)
  record      = association&.reader
  association_valid?(reflection, record) if record
end