• Introduction:

1. Rails provide a powerful mechanism for creating rich forms called ‘nested attributes’ easily.

2. Nested attributes allow you to save attributes on associated records through the parent model. 

3. This is useful for forms that handle multiple models at once.

4.  The updating of the nested attribute is turned off by default and can be enabled using the class method ‘accepts_nested_attributes_for’.

5. It creates a scope around a specific model object like ‘form_for’ , but doesn’t create the form tags themselves.
6. This makes ‘fields_for’ suitable for specifying additional model objects in the same form 

• Implementation

•  One to One relationship :

1. The ‘has_one’ and ‘belongs_to’ associations sets up a one-to-one connection with another model, such that each instance of a model contains or possesses one instance of another model and each instance of the declaring model ‘belongs to’ one instance of the other model.
2. Nested Attributes’s simplest example is a one-to-one association. The example below is how to make an online store with lots of products.
3. Each product have one image and each image has the attributes such as url, alt, and caption.
4. If you use ‘accept_nested_attributes_for’ in combination with a ‘has_many’ association, you get these kinds of parameters.
    

Class Product < ActiveRecord::Base
   has_one :image
  accept_nested_attributes_for :image
 # Attributes: name:string, price:float
end

 

Also, each Product is associated with one Image record, which contains an url, alt, and a caption.

 

Class Image < ActiveRecord::Base
  belongs_to :product
 #Attributes: url:string, alt:string, caption:string
end

 What does this do, exactly?

It would proxy the Product model’s saved attributes to the Image model. You will need to add additional fields to the image association in the Product form. You can do it by using the ‘fields_for’ helper.

 

= form_for @product do |f|
  # Product attributes
  .form-group
    = f.label :name
    = f.text_field :name
  .form-group
    = f.label :price
    = f.text_field :price

  # Image attributes
  = f.fields_for :image do |form|
    = form.label :url
    = form.text_field :url

    = form.label :alt
    = form.text_field :alt

    = form.label :caption
    = form.text_field :caption
= f.submit

• Modify the Controller: Adjust the controller to accept the new nested attributes.
•  Purpose of Nested Attributes: The main idea behind Nested Attributes is to avoid adding extra code to the controller for handling input and associations.
• Allow Attributes to Reach the Model: Ensure the nested attributes can reach the model, as Strong Parameters would prevent this by default.
• Update Strong Parameters: Add the necessary nested attributes to the product_params method in the Products Controller.

 

def product_params
  params.require(:product).permit(
    :name, :price,
    image_attributes: [ :id, :url, :alt, :caption ] 
  )
end

•  One to Many relationship:

1. Now in many to many relationship we will take the same example for Product and Images but modifying it a little bit
2.  Here we will consider that one Product may have one or more images. Product images are quite simple (just two fields), so it really doesn’t make sense to create a separate page to edit them.
3. Instead, together with the product attributes, we would like to edit them in-line from the same product form.
4. And since each product can have a lot of images, we will have to handle more than one item. We need to add new images and delete old ones as well.  
5.  Following will be the modifications in Product model to have multiple images for the Product, ‘has_one’ association for images will be replaced with ‘has_many’ association.

 

class Product < ActiveRecord::Base
  has_many :images
  accepts_nested_attributes_for :images
end 

 Summary:

 Nested attributes in Rails provide a powerful way to manage associated records within forms. Whether it's a simple one-to-one relationship or a more complex one-to-many relationship, leveraging accepts_nested_attributes_for and adjusting your form and controller appropriately simplifies handling nested models.

By following these steps, you can effectively manage and update related records like images along with your main model (e.g., products) in a single form submission, enhancing user experience and code maintainability in your Rails applications.