Association callbacks in Ruby on Rails - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a callback that runs after a comment is created.

Ruby on Rails

class Comment < ApplicationRecord
  belongs_to :post
  after_[1] :notify_post_author

  def notify_post_author
    # notification logic here
  end
end

Drag options to blanks, or click blank then click option'

Asave

Bcreate

Cupdate

Ddestroy

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'after_save' which runs on both create and update, not just creation.

Using 'after_destroy' which runs after deletion, not creation.

The 'after_create' callback runs only after a new record is created, which is suitable for notifying after a comment is added.

2fill in blank

medium

Complete the code to run a callback before a post is destroyed to clean up associated comments.

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments, dependent: :destroy
  before_[1] :cleanup_comments

  def cleanup_comments
    comments.destroy_all
  end
end

Drag options to blanks, or click blank then click option'

Asave

Bupdate

Ccreate

Ddestroy

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'before_save' which runs on create and update, not on destroy.

Using 'after_destroy' which runs after deletion, too late for cleanup.

The 'before_destroy' callback runs before the post is deleted, allowing cleanup of associated comments.

3fill in blank

hard

Fix the error in the callback method name to correctly run after a post's comments are added.

Ruby on Rails

class Post < ApplicationRecord
  has_many :comments, after_add: :[1]

  def log_comment_addition(comment)
    # log logic here
  end
end

Drag options to blanks, or click blank then click option'

Alog_comment_addition

Blog_comment_added

Clog_comment_add

Dlog_added_comment

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name that does not match the callback symbol.

Misnaming the callback method causing it not to run.

The 'after_add' callback for the comments association runs after a comment is added. The method receives the added comment as an argument. The method name must match the symbol passed.

4fill in blank

hard

Fill both blanks to define a callback that runs before adding a tag to a post and calls the correct method.

Ruby on Rails

class Post < ApplicationRecord
  has_many :tags, [1]: :[2]

  def check_tag_limit(tag)
    # limit check logic
  end
end

Drag options to blanks, or click blank then click option'

Abefore_add

Bafter_add

Ccheck_tag_limit

Dvalidate_tag_limit

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'after_add' instead of 'before_add' for pre-add checks.

Mismatching method names causing callbacks not to trigger.

The 'before_add' callback for the tags association runs before a tag is added, and the method 'check_tag_limit' (receiving the tag) is the correct handler.

5fill in blank

hard

Fill all three blanks to define callbacks that run before adding and after removing categories from a product.

Ruby on Rails

class Product < ApplicationRecord
  has_many :categories, [1]: :[2], [3]: :log_category_removal

  def log_category_addition(category)
    # log addition
  end
end

Drag options to blanks, or click blank then click option'

Abefore_add

Blog_category_addition

Cafter_remove

Dbefore_remove

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'before_remove' instead of 'after_remove' for post-removal actions.

Mismatching method names causing callbacks not to execute.

The 'before_add' callback for the categories association runs before adding a category and calls 'log_category_addition(category)'. The 'after_remove' callback runs after removing a category and calls 'log_category_removal(category)'.

Practice

1. What is the purpose of after_add and after_remove callbacks in Rails associations?

easy

A. To define database indexes on associations

B. To validate the presence of associated records

C. To preload associated records for performance

D. To run code automatically when related records are added or removed

Solution

1. Step 1: Understand association callbacks

   Rails provides after_add and after_remove callbacks to trigger code when associated records change.

2. Step 2: Identify their purpose

   These callbacks run automatically when you add or remove related records, helping keep data in sync.

3. Final Answer:

   To run code automatically when related records are added or removed -> Option D

4. Quick Check:

   Association callbacks = automatic code on add/remove [OK]

Hint: Callbacks run code on add/remove related records [OK]

Common Mistakes:

• Confusing callbacks with validations
• Thinking callbacks preload data
• Assuming callbacks define indexes

2. Which is the correct syntax to add an after_add callback to a has_many association named comments in a Rails model?

easy

A. has_many :comments, after_add: :notify_comment_added

B. has_many :comments, after_add => :notify_comment_added

C. has_many :comments do after_add :notify_comment_added end

D. has_many :comments, callback_after_add: :notify_comment_added

Solution

1. Step 1: Recall correct hash syntax for options

   Rails uses symbol keys with colon and value pairs like after_add: :method_name.

2. Step 2: Match syntax to association

   The correct syntax is has_many :comments, after_add: :notify_comment_added.

3. Final Answer:

   has_many :comments, after_add: :notify_comment_added -> Option A

4. Quick Check:

   Use colon syntax for options in associations [OK]

Hint: Use colon syntax for options in associations [OK]

Common Mistakes:

• Using hash rocket => instead of colon :
• Trying to define callback inside block
• Using wrong option name like callback_after_add

3. Given the following code, what will be printed when a new comment is added to a Post?

class Post < ApplicationRecord
  has_many :comments, after_add: :log_comment_added

  def log_comment_added(comment)
    puts "Comment added: #{comment.body}"
  end
end

post = Post.new
post.comments << Comment.new(body: 'Nice post!')

medium

A. No output

B. Comment added: Nice post!

C. Error: undefined method log_comment_added

D. Comment added:

Solution

1. Step 1: Understand after_add callback behavior

   The after_add callback calls log_comment_added with the new comment when added.

2. Step 2: Check the method output

   The method prints "Comment added: " plus the comment's body, which is "Nice post!".

3. Final Answer:

   Comment added: Nice post! -> Option B

4. Quick Check:

   after_add calls method with new record [OK]

Hint: after_add calls method with added record [OK]

Common Mistakes:

• Expecting no output
• Thinking callback is not triggered on << operator
• Assuming method is missing error

4. Identify the error in this Rails model code using after_remove callback:

class User < ApplicationRecord
  has_many :posts, after_remove: :notify_post_removed

  def notify_post_removed
    puts 'Post removed'
  end
end

medium

A. The callback method must accept the removed record as an argument

B. The callback name should be after_remove_post

C. The after_remove option is not valid for has_many

D. The method should be private

Solution

1. Step 1: Check callback method signature

   Callbacks like after_remove receive the removed record as an argument.

2. Step 2: Compare method definition

   The method notify_post_removed has no parameters, so it will cause an error.

3. Final Answer:

   The callback method must accept the removed record as an argument -> Option A

4. Quick Check:

   Callback methods need removed record argument [OK]

Hint: Callback methods must accept the changed record argument [OK]

Common Mistakes:

• Defining callback method without parameters
• Using invalid callback option name
• Thinking method visibility causes error

5. You want to track when tags are added or removed from an Article model using has_many :tags. You want to update a counter on Article each time tags change. Which is the best way to implement this using association callbacks?

hard

A. Use before_save callback on Article to count tags

B. Override the tags= setter method to update the counter

C. Use after_add and after_remove callbacks on has_many :tags to update the counter method

D. Manually call a method to update the counter after changing tags

Solution

1. Step 1: Understand the goal

   You want to update a counter automatically when tags are added or removed.

2. Step 2: Choose appropriate callback

   after_add and after_remove on has_many :tags run code exactly when tags change.

3. Step 3: Compare other options

   Overriding setter or using before_save is less direct and can miss changes; manual calls are error-prone.

4. Final Answer:

   Use after_add and after_remove callbacks on has_many :tags to update the counter method -> Option C

5. Quick Check:

   Use association callbacks for automatic related record updates [OK]

Hint: Use after_add and after_remove for automatic updates [OK]

Common Mistakes:

• Overriding setter unnecessarily
• Using before_save which may miss association changes
• Forgetting to automate updates