Underscore destroy method - ruby-on-rails

Question

for code below after checking checkbox on particular answer the answer will be deleted after submitting form.
Can somwone please explain if this destroy method needs to be defined anywhere or is that a default? I cannot find any documentation. Actually how this functionality works?
The source is from here:
http://railscasts.com/episodes/196-nested-model-form-part-1?autoplay=true
<p>
<%= f.label :content, "Answer" %>
<%= f.text_field :content %>
<%= f.check_box :_destroy %>
<%= f.label :_destroy, "Remove" %>
</p>

Answer 1

Short Answer:
For this, to work we define accepts_nested_attributes_for on the parent model which does all the magic.
Long Answer: (How accepts_nested_attributes_for does this magic?)
This is the source code:
def accepts_nested_attributes_for(*attr_names)
options = { allow_destroy: false, update_only: false }
options.update(attr_names.extract_options!)
options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
attr_names.each do |association_name|
if reflection = _reflect_on_association(association_name)
reflection.autosave = true
define_autosave_validation_callbacks(reflection)
nested_attributes_options = self.nested_attributes_options.dup
nested_attributes_options[association_name.to_sym] = options
self.nested_attributes_options = nested_attributes_options
type = (reflection.collection? ? :collection : :one_to_one)
generate_association_writer(association_name, type)
else
raise ArgumentError, "No association found for name `#{association_name}'. Has it been defined yet?"
end
end
end
Here you can see it calls generate_association_writer(association_name, type) which defines the setter method like this:
def generate_association_writer(association_name, type)
generated_association_methods.module_eval <<-eoruby, __FILE__, __LINE__ + 1
silence_redefinition_of_method :#{association_name}_attributes=
def #{association_name}_attributes=(attributes)
assign_nested_attributes_for_#{type}_association(:#{association_name}, attributes)
end
eoruby
end
Suppose you have this class:
class BlogPost < ApplicationRecord
has_many :comments
accepts_nested_attributes_for :comments, allow_destroy: true
end
Then this will generate: comments_attributes= setter method dynamically on the model. Now from the view when you add a block:
<% f.fields_for :comments do |comment| %>
<% end %>
It passes the values in the comments_attributes key (if you check the params on the controller you will find that also you have to whitelist this attribute on strong params to make it work). So this automatically calls the generated setter method.
Now based on the type of association (single or collection) it calls assign_nested_attributes_for_one_to_one_association or assign_nested_attributes_for_collection_association method which calls assign_to_or_mark_for_destruction which marks the object for destruction if _destroy is true if you have allowed to destroy and it is an existing object.
For reference:
def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
options = nested_attributes_options[association_name]
if attributes.respond_to?(:permitted?)
attributes = attributes.to_h
end
attributes = attributes.with_indifferent_access
existing_record = send(association_name)
if (options[:update_only] || !attributes["id"].blank?) && existing_record &&
(options[:update_only] || existing_record.id.to_s == attributes["id"].to_s)
assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy]) unless call_reject_if(association_name, attributes)
elsif attributes["id"].present?
raise_nested_attributes_record_not_found!(association_name, attributes["id"])
elsif !reject_new_record?(association_name, attributes)
assignable_attributes = attributes.except(*UNASSIGNABLE_KEYS)
if existing_record && existing_record.new_record?
existing_record.assign_attributes(assignable_attributes)
association(association_name).initialize_attributes(existing_record)
else
method = :"build_#{association_name}"
if respond_to?(method)
send(method, assignable_attributes)
else
raise ArgumentError, "Cannot build association `#{association_name}'. Are you trying to build a polymorphic one-to-one association?"
end
end
end
end
def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
options = nested_attributes_options[association_name]
if attributes_collection.respond_to?(:permitted?)
attributes_collection = attributes_collection.to_h
end
unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
raise ArgumentError, "Hash or Array expected for attribute `#{association_name}`, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
end
check_record_limit!(options[:limit], attributes_collection)
if attributes_collection.is_a? Hash
keys = attributes_collection.keys
attributes_collection = if keys.include?("id") || keys.include?(:id)
[attributes_collection]
else
attributes_collection.values
end
end
association = association(association_name)
existing_records = if association.loaded?
association.target
else
attribute_ids = attributes_collection.filter_map { |a| a["id"] || a[:id] }
attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
end
attributes_collection.each do |attributes|
if attributes.respond_to?(:permitted?)
attributes = attributes.to_h
end
attributes = attributes.with_indifferent_access
if attributes["id"].blank?
unless reject_new_record?(association_name, attributes)
association.reader.build(attributes.except(*UNASSIGNABLE_KEYS))
end
elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes["id"].to_s }
unless call_reject_if(association_name, attributes)
# Make sure we are operating on the actual object which is in the association's
# proxy_target array (either by finding it, or adding it if not found)
# Take into account that the proxy_target may have changed due to callbacks
target_record = association.target.detect { |record| record.id.to_s == attributes["id"].to_s }
if target_record
existing_record = target_record
else
association.add_to_target(existing_record, skip_callbacks: true)
end
assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
end
else
raise_nested_attributes_record_not_found!(association_name, attributes["id"])
end
end
end
def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
record.assign_attributes(attributes.except(*UNASSIGNABLE_KEYS))
record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
end
def has_destroy_flag?(hash)
Type::Boolean.new.cast(hash["_destroy"])
end
You would find all the code in activerecord/lib/active_record/nested_attributes.rb class: https://github.com/rails/rails/blob/main/activerecord/lib/active_record/nested_attributes.rb

Answer 2

The _destroy 'attribute' functionality is part of working with nested forms/attributes.
Suppose you have a Quiz model that has_many :answers. To be able to update a Quiz and its child Answer objects in one operation, you declare that with accepts_nested_attributes_for:
class Quiz < ApplicationRecord
has_many :answers
accepts_nested_attributes_for :answers
end
If your form uses the <% f.fields_for :answers %> construct (shown in your video), Rails will organize the parameter hash so that you can update the parent quiz and it will also automatically create/update any child answers. By default, though, you can only update an existing child or create new ones. If you want to also be able to delete nested objects, you need first to explicitly enable it in the model:
class Quiz < ApplicationRecord
has_many :answers
accepts_nested_attributes_for :answers, allow_destroy: true
end
Then, per the API docs for NestedAttributes:
when you add the _destroy key to the attributes hash, with a value
that evaluates to true, you will destroy the associated model.
So, as long as you have enabled nested destruction on the model, adding a f.check_box :_destroy field to your nested form, Rails will automagically remove the marked record.