module ActiveEntity::ValidateEmbedsAssociation
Active Entity 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 < ActiveEntity::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 < ActiveEntity::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 < ActiveEntity::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
Public Instance Methods
Returns the association for the parent being destroyed.
Used to avoid updating the counter cache unnecessarily.
# File lib/active_entity/validate_embeds_association.rb, line 228 def destroyed_by_association @destroyed_by_association end
Records the association that is being destroyed and destroying this record in the process.
# File lib/active_entity/validate_embeds_association.rb, line 221 def destroyed_by_association=(reflection) @destroyed_by_association = reflection end
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.
# File lib/active_entity/validate_embeds_association.rb, line 208 def mark_for_destruction @marked_for_destruction = true end
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.
# File lib/active_entity/validate_embeds_association.rb, line 215 def marked_for_destruction? @marked_for_destruction end
Private Instance Methods
# File lib/active_entity/validate_embeds_association.rb, line 299 def _ensure_no_duplicate_errors errors.messages.each_key do |attribute| errors[attribute].uniq! end end
Returns the record for an association collection that should be validated or saved. If autosave
is false
only new records will be returned, unless the parent is/was a new record itself.
# File lib/active_entity/validate_embeds_association.rb, line 237 def associated_records_to_validate(association) association&.target end
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/active_entity/validate_embeds_association.rb, line 263 def association_valid?(reflection, record, index = nil) return true if record.marked_for_destruction? context = validation_context unless valid = record.valid?(context) indexed_attribute = !index.nil? && (reflection.options[:index_errors] || ActiveEntity::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
# File lib/active_entity/validate_embeds_association.rb, line 291 def normalize_reflection_attribute(indexed_attribute, reflection, index, attribute) if indexed_attribute "#{reflection.name}[#{index}].#{attribute}" else "#{reflection.name}.#{attribute}" end end
Validate the associated records if :validate
or :autosave
is turned on for the association specified by reflection
.
# File lib/active_entity/validate_embeds_association.rb, line 252 def validate_collection_association(reflection) if association = association_instance_get(reflection.name) if records = associated_records_to_validate(association) records.each_with_index { |record, index| association_valid?(reflection, record, index) } end end end
Validate the association if :validate
or :autosave
is turned on for the association.
# File lib/active_entity/validate_embeds_association.rb, line 243 def validate_single_association(reflection) association = association_instance_get(reflection.name) record = association&.reader association_valid?(reflection, record) if record end