- 1.0.0
- 1.1.6
- 1.2.6
- 2.0.3
- 2.1.0
- 2.2.1
- 2.3.8 (0)
- 3.0.0 (1)
- 3.0.9 (-12)
- 3.1.0 (31)
- 3.2.1 (0)
- 3.2.8 (0)
- 3.2.13 (0)
- 4.0.2 (38)
- 4.1.8 (6)
- 4.2.1 (0)
- 4.2.7 (0)
- 4.2.9 (0)
- 5.0.0.1 (11)
- 5.1.7 (0)
- 5.2.3 (15)
- 6.0.0 (0)
- 6.1.3.1 (0)
- 6.1.7.7 (0)
- 7.0.0 (6)
- 7.1.3.2 (15)
- 7.1.3.4 (0)
- What's this?
Active Record Nested Attributes
Nested attributes allow you to save attributes on associated records through the parent. By default nested attribute updating is turned off and you can enable it using the accepts_nested_attributes_for class method. When you enable nested attributes an attribute writer is defined on the model.
The attribute writer is named after the association, which means that in the following example, two new methods are added to your model:
author_attributes=(attributes) and pages_attributes=(attributes).
class Book < ActiveRecord::Base has_one :author has_many :pages accepts_nested_attributes_for :author, :pages end
Note that the :autosave option is automatically enabled on every association that accepts_nested_attributes_for is used for.
One-to-one
Consider a Member model that has one Avatar:
class Member < ActiveRecord::Base has_one :avatar accepts_nested_attributes_for :avatar end
Enabling nested attributes on a one-to-one association allows you to create the member and avatar in one go:
params = { member: { name: 'Jack', avatar_attributes: { icon: 'smiling' } } } member = Member.create(params[:member]) member.avatar.id # => 2 member.avatar.icon # => 'smiling'
It also allows you to update the avatar through the member:
params = { member: { avatar_attributes: { id: '2', icon: 'sad' } } } member.update params[:member] member.avatar.icon # => 'sad'
If you want to update the current avatar without providing the id, you must add :update_only option.
class Member < ActiveRecord::Base has_one :avatar accepts_nested_attributes_for :avatar, update_only: true end params = { member: { avatar_attributes: { icon: 'sad' } } } member.update params[:member] member.avatar.id # => 2 member.avatar.icon # => 'sad'
By default you will only be able to set and update attributes on the associated model. If you want to destroy the associated model through the attributes hash, you have to enable it first using the :allow_destroy option.
class Member < ActiveRecord::Base has_one :avatar accepts_nested_attributes_for :avatar, allow_destroy: true end
Now, when you add the _destroy key to the attributes hash, with a value that evaluates to true, you will destroy the associated model:
member.avatar_attributes = { id: '2', _destroy: '1' } member.avatar.marked_for_destruction? # => true member.save member.reload.avatar # => nil
Note that the model will not be destroyed until the parent is saved.
Also note that the model will not be destroyed unless you also specify its id in the updated hash.
One-to-many
Consider a member that has a number of posts:
class Member < ActiveRecord::Base has_many :posts accepts_nested_attributes_for :posts end
You can now set or update attributes on the associated posts through an attribute hash for a member: include the key :posts_attributes with an array of hashes of post attributes as a value.
For each hash that does not have an id key a new record will be instantiated, unless the hash also contains a _destroy key that evaluates to true.
params = { member: { name: 'joe', posts_attributes: [ { title: 'Kari, the awesome Ruby documentation browser!' }, { title: 'The egalitarian assumption of the modern citizen' }, { title: '', _destroy: '1' } # this will be ignored ] }} member = Member.create(params[:member]) member.posts.length # => 2 member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!' member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
You may also set a :reject_if proc to silently ignore any new record hashes if they fail to pass your criteria. For example, the previous example could be rewritten as:
class Member < ActiveRecord::Base has_many :posts accepts_nested_attributes_for :posts, reject_if: proc { |attributes| attributes['title'].blank? } end params = { member: { name: 'joe', posts_attributes: [ { title: 'Kari, the awesome Ruby documentation browser!' }, { title: 'The egalitarian assumption of the modern citizen' }, { title: '' } # this will be ignored because of the :reject_if proc ] }} member = Member.create(params[:member]) member.posts.length # => 2 member.posts.first.title # => 'Kari, the awesome Ruby documentation browser!' member.posts.second.title # => 'The egalitarian assumption of the modern citizen'
Alternatively, :reject_if also accepts a symbol for using methods:
class Member < ActiveRecord::Base has_many :posts accepts_nested_attributes_for :posts, reject_if: :new_record? end class Member < ActiveRecord::Base has_many :posts accepts_nested_attributes_for :posts, reject_if: :reject_posts def reject_posts(attributes) attributes['title'].blank? end end
If the hash contains an id key that matches an already associated record, the matching record will be modified:
member.attributes = { name: 'Joe', posts_attributes: [ { id: 1, title: '[UPDATED] An, as of yet, undisclosed awesome Ruby documentation browser!' }, { id: 2, title: '[UPDATED] other post' } ] } member.posts.first.title # => '[UPDATED] An, as of yet, undisclosed awesome Ruby documentation browser!' member.posts.second.title # => '[UPDATED] other post'
However, the above applies if the parent model is being updated as well. For example, If you wanted to create a member named joe and wanted to update the posts at the same time, that would give an ActiveRecord::RecordNotFound error.
By default the associated records are protected from being destroyed. If you want to destroy any of the associated records through the attributes hash, you have to enable it first using the :allow_destroy option. This will allow you to also use the _destroy key to destroy existing records:
class Member < ActiveRecord::Base has_many :posts accepts_nested_attributes_for :posts, allow_destroy: true end params = { member: { posts_attributes: [{ id: '2', _destroy: '1' }] }} member.attributes = params[:member] member.posts.detect { |p| p.id == 2 }.marked_for_destruction? # => true member.posts.length # => 2 member.save member.reload.posts.length # => 1
Nested attributes for an associated collection can also be passed in the form of a hash of hashes instead of an array of hashes:
Member.create( name: 'joe', posts_attributes: { first: { title: 'Foo' }, second: { title: 'Bar' } } )
has the same effect as
Member.create( name: 'joe', posts_attributes: [ { title: 'Foo' }, { title: 'Bar' } ] )
The keys of the hash which is the value for :posts_attributes are ignored in this case. However, it is not allowed to use 'id' or :id for one of such keys, otherwise the hash will be wrapped in an array and interpreted as an attribute hash for a single post.
Passing attributes for an associated collection in the form of a hash of hashes can be used with hashes generated from HTTP/HTML parameters, where there may be no natural way to submit an array of hashes.
Saving
All changes to models, including the destruction of those marked for destruction, are saved and destroyed automatically and atomically when the parent model is saved. This happens inside the transaction initiated by the parent’s save method. See ActiveRecord::AutosaveAssociation.
Validating the presence of a parent model
If you want to validate that a child record is associated with a parent record, you can use the validates_presence_of method and the :inverse_of key as this example illustrates:
class Member < ActiveRecord::Base has_many :posts, inverse_of: :member accepts_nested_attributes_for :posts end class Post < ActiveRecord::Base belongs_to :member, inverse_of: :posts validates_presence_of :member end
Note that if you do not specify the :inverse_of option, then Active Record will try to automatically guess the inverse association based on heuristics.
For one-to-one nested associations, if you build the new (in-memory) child object yourself before assignment, then this module will not overwrite it, e.g.:
class Member < ActiveRecord::Base has_one :avatar accepts_nested_attributes_for :avatar def avatar super || build_avatar(width: 200) end end member = Member.new member.avatar_attributes = {icon: 'sad'} member.avatar.width # => 200
Constants
REJECT_ALL_BLANK_PROC = proc { |attributes| attributes.all? { |key, value| key == "_destroy" || value.blank? } }
Attributes
Validating presence of parent in child
When creating a parent and its children using nested attributes, you can use the :inverse_of option on the association to correctly set the parent back references:
class Parent < ActiveRecord::Base has_many :children, :inverse_of => :parent accepts_nested_attributes_for :children end class Child < ActiveRecord::Base belongs_to :parent validates_presence_of :parent end
Updating nested attributes of one-to-one associations
As the documentation implicitly mentions, when updating nested attributes of a one-to-one relationship, you need to pass the ID of the nested attribute itself, otherwise a new record will be created.
This works fine:
params = { :member => { :avatar_attributes => { :id => '2', :icon => 'sad' } } }
However, the following line will build and save a new record, which is usually not what you want for one-to-one:
params = { :member => { :avatar_attributes => { :icon => 'sad' } } }
Alternatively, you can use the ‘update_only’ option. This option will ensure that an existing record will always be updated, even if the ID is not specified:
accepts_nested_attributes_for :avatar, :update_only => true