123456789_123456789_123456789_123456789_123456789_

Module: ActiveRecord::AutosaveAssociation

Relationships & Source Files
Extension / Inclusion / Inheritance Descendants
Included In:
Super Chains via Extension / Inclusion / Inheritance
Class Chain:
Defined in: activerecord/lib/active_record/autosave_association.rb

Overview

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 (around_save, 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')
comment = post.comments.create(body: 'hello world')
comment.body = 'hi everyone'
post.save # => saves post, but not 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')
comment = post.comments.create(body: 'hello world')
comment.body = 'hi everyone'
post.comments.build(body: "good morning.")
post.save # => saves post and both 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

Caveats

Note that autosave will only trigger for already-persisted association records if the records themselves have been changed. This is to protect against SystemStackError caused by circular association validations. The one exception is if a custom validation context is used, in which case the validations will always fire on the associated records.

Class Method Summary

::ActiveSupport::Concern - Extended

class_methods

Define class methods from given block.

included

Evaluate given block in context of base class, so that you can write class macros here.

prepended

Evaluate given block in context of base class, so that you can write class macros here.

Instance Attribute Summary

Instance Method Summary

DSL Calls

included

[ GitHub ]


151
152
153
# File 'activerecord/lib/active_record/autosave_association.rb', line 151

included do
  Associations::Builder::Association.extensions << AssociationBuilderExtension
end

Instance Attribute Details

#changed_for_autosave?Boolean (readonly)

Returns whether or not this record has been changed in any way (including whether any of its nested autosave associations are likewise changed)

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 271

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

#destroyed_by_association (rw)

Returns the association for the parent being destroyed.

Used to avoid updating the counter cache unnecessarily.

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 265

def destroyed_by_association
  @destroyed_by_association
end

#destroyed_by_association=(reflection) (rw)

Records the association that is being destroyed and destroying this record in the process.

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 258

def destroyed_by_association=(reflection)
  @destroyed_by_association = reflection
end

#marked_for_destruction?Boolean (readonly)

Returns whether or not this record will be destroyed as part of the parent’s save transaction.

Only useful if the :autosave option on the parent is enabled for this associated model.

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 252

def marked_for_destruction?
  @marked_for_destruction
end

Instance Method Details

#mark_for_destruction

Marks this record to be destroyed as part of the parent’s save transaction. This does not actually destroy the record instantly, rather child record will be destroyed when parent.save is called.

Only useful if the :autosave option on the parent is enabled for this associated model.

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 245

def mark_for_destruction
  @marked_for_destruction = true
end

#reload(options = nil)

Reloads the attributes of the object as usual and clears marked_for_destruction flag.

[ GitHub ]

  
# File 'activerecord/lib/active_record/autosave_association.rb', line 234

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