module DatastaxRails::AutosaveAssociation
DatastaxRails
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?
).
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¶ ↑
Children 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 the 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 has_one :author, autosave: true end
Saving changes to the parent and its associated model can now be performed automatically:
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 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 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.save # => saves both post and comment, with 'hi everyone' as body
Destroying one of the associated models as part of the parent's save action is as simple as marking it for destruction:
post.comments.last.mark_for_destruction post.comments.last.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
Attributes
Records the association that is being destroyed and destroying this record in the process.
Returns whether or not this record will be destroyed as part of the parents save transaction.
Only useful if the :autosave
option on the parent is enabled for this associated model.
Returns whether or not this record will be destroyed as part of the parents save transaction.
Only useful if the :autosave
option on the parent is enabled for this associated model.
Public Instance Methods
Returns whether or not this record has been changed in any way (including whether any of its nested autosave associations are likewise changed)
# File lib/datastax_rails/autosave_association.rb, line 246 def changed_for_autosave? new_record? || changed? || marked_for_destruction? || nested_records_changed_for_autosave? end
Marks this record to be destroyed as part of the parents 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/datastax_rails/autosave_association.rb, line 225 def mark_for_destruction @marked_for_destruction = true end
Reloads the attributes of the object as usual and clears marked_for_destruction
flag.
# File lib/datastax_rails/autosave_association.rb, line 214 def reload(options = nil) @marked_for_destruction = false @destroyed_by_association = nil super end
Private Instance Methods
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/datastax_rails/autosave_association.rb, line 255 def associated_records_to_validate_or_save(association, new_record, autosave) if new_record association && association.target elsif autosave association.target.select(&:changed_for_autosave?) else association.target.select(&:new_record?) end 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/datastax_rails/autosave_association.rb, line 299 def association_valid?(reflection, record) return true if record.destroyed? || record.marked_for_destruction? unless (valid = record.valid?) if reflection.options[:autosave] record.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
Is used as a before_save callback to check while saving a collection association whether or not the parent was a new record before saving.
# File lib/datastax_rails/autosave_association.rb, line 318 def before_save_collection_association @new_record_before_save = new_record? true end
go through nested autosave associations that are loaded in memory (without loading any new ones), and return true if is changed for autosave
# File lib/datastax_rails/autosave_association.rb, line 267 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?(&:changed_for_autosave?) end end
If the record is new or it has changed, returns true.
# File lib/datastax_rails/autosave_association.rb, line 400 def record_changed?(reflection, record, key) record.new_record? || record[reflection.foreign_key] != key || record.changed_attributes.include?(reflection.foreign_key) end
Saves the associated record if it's new or :autosave
is enabled.
In addition, it will destroy the association if it was marked for destruction.
# File lib/datastax_rails/autosave_association.rb, line 409 def save_belongs_to_association(reflection) association = association_instance_get(reflection.name) record = association && association.load_target if record && !record.destroyed? autosave = reflection.options[:autosave] if autosave && record.marked_for_destruction? self[reflection.foreign_key] = nil record.destroy elsif autosave != false saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?) if association.updated? association_id = record.send(reflection.options[:primary_key] || :id) self[reflection.foreign_key] = association_id association.loaded! end saved if autosave end end end
Saves any new associated records, or all loaded autosave associations if :autosave
is enabled on the association.
In addition, it destroys all children that were marked for destruction with mark_for_destruction.
rubocop:disable Metrics/BlockNesting
# File lib/datastax_rails/autosave_association.rb, line 330 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)) if autosave records_to_destroy = records.select(&:marked_for_destruction?) records_to_destroy.each { |record| association.destroy(record) } records -= records_to_destroy end records.each do |record| next if record.destroyed? saved = true if autosave != false && (@new_record_before_save || record.new_record?) if autosave saved = association.insert_record(record, false) else association.insert_record(record) unless reflection.nested? end elsif autosave saved = record.save(validate: false) end fail ActiveRecord::Rollback unless saved end @new_record_before_save = false unless reflection.macro == :has_and_belongs_to_many end # reconstruct the scope now that we know the owner's id association.reset_scope if association.respond_to?(:reset_scope) end end
Saves the associated record if it's new or :autosave
is enabled on the association.
In addition, it will destroy the association if it was marked for destruction with mark_for_destruction.
This all happens inside a transaction, if the Transactions module is included into ActiveRecord::Base after the AutosaveAssociation
module, which it does by default.
# File lib/datastax_rails/autosave_association.rb, line 375 def save_has_one_association(reflection) association = association_instance_get(reflection.name) record = association && association.load_target if record && !record.destroyed? autosave = reflection.options[:autosave] if autosave && record.marked_for_destruction? record.destroy elsif autosave != false key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key) unless reflection.through_reflection record[reflection.foreign_key] = key end saved = record.save(validate: !autosave) fail ActiveRecord::Rollback if !saved && autosave saved end end end end
Validate the associated records if :validate
or :autosave
is turned on for the association specified by reflection
.
# File lib/datastax_rails/autosave_association.rb, line 285 def validate_collection_association(reflection) if (association = association_instance_get(reflection.name)) records = associated_records_to_validate_or_save(association, new_record?, reflection.options[:autosave]) if records records.each { |record| association_valid?(reflection, record) } end end end
Validate the association if :validate
or :autosave
is turned on for the association.
# File lib/datastax_rails/autosave_association.rb, line 276 def validate_single_association(reflection) association = association_instance_get(reflection.name) record = association && association.reader association_valid?(reflection, record) if record end