Callbacks overview in Ruby on Rails - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a callback in Rails?

A callback in Rails is a method that gets called at certain points in an object's life cycle, like before saving or after creating a record.

beginner

Name two common types of callbacks in Rails.

Two common callbacks are before_save and after_create. They run before saving and after creating a record, respectively.

intermediate

How do callbacks help in managing data integrity?

Callbacks let you run code automatically to check or change data before saving, ensuring the data stays correct and consistent.

intermediate

What is the difference between before_save and after_save callbacks?

before_save runs before the record is saved to the database, allowing changes or checks. after_save runs after the record is saved, useful for actions that depend on the saved data.

intermediate

Can callbacks stop a save operation in Rails? How?

Yes, callbacks like before_save can stop saving by throwing an exception or by adding errors to the object, which prevents the save.

Which callback runs right before a record is saved in Rails?

A before_create

B before_save

C after_save

D after_create

before_save runs just before saving a record, allowing changes or checks.

What happens if a before_save callback returns false?

A The save operation is canceled

B The save operation continues

C An error is raised immediately

D The callback is ignored

Returning false in a before_save callback used to stop the save operation in older Rails versions, but in modern Rails versions, you should throw an exception or add errors to stop saving.

Which callback would you use to run code after a new record is created?

A after_create

B before_create

C before_save

D after_save

after_create runs after a new record is successfully created.

Callbacks in Rails are mainly used to:

A Handle user authentication

B Manually trigger database queries

C Replace model validations

D Automatically run code at certain object lifecycle events

Callbacks automatically run code at specific points like before saving or after creating.

Which callback is best to modify data before saving it to the database?

A after_create

B after_save

C before_save

D after_destroy

before_save allows you to change data before it is saved.

Explain what Rails callbacks are and give two examples of when they run.

Think about moments in a record's life like saving or creating.

Describe how callbacks can be used to prevent saving invalid data in Rails.

Consider how callbacks can stop an action if conditions are not met.

Practice

1. What is the main purpose of callbacks in Rails models?

easy

A. To run code automatically at specific points in a model's life

B. To manually call methods from controllers

C. To style the HTML output of views

D. To handle database migrations

Solution

1. Step 1: Understand what callbacks do

   Callbacks are hooks that run code automatically during certain model events like saving or deleting.

2. Step 2: Identify the correct purpose

   Callbacks help automate tasks at specific points in a model's lifecycle, not manual calls or styling.

3. Final Answer:

   To run code automatically at specific points in a model's life -> Option A

4. Quick Check:

   Callbacks = automatic code run [OK]

Hint: Callbacks run code automatically at model events [OK]

Common Mistakes:

• Confusing callbacks with controller methods
• Thinking callbacks style views
• Mixing callbacks with database migrations

2. Which of the following is the correct syntax to define a callback that runs before saving a record?

easy

A. on_save :method_name

B. after_save :method_name

C. before_save do method_name end

D. before_save :method_name

Solution

1. Step 1: Recall callback syntax

   Rails uses before_save :method_name to run a method before saving a record.

2. Step 2: Check other options

   after_save runs after saving, on_save is invalid, and the block syntax is incorrect here.

3. Final Answer:

   before_save :method_name -> Option D

4. Quick Check:

   before_save syntax = before_save :method_name [OK]

Hint: Use before_save :method_name to run code before saving [OK]

Common Mistakes:

• Using after_save instead of before_save
• Trying to use on_save which doesn't exist
• Incorrect block syntax for callbacks

3. Given this model code:

class User < ApplicationRecord
  before_create :set_default_role

  def set_default_role
    self.role ||= 'guest'
  end
end

What will be the role of a new User if none is set before saving?

medium

A. 'guest'

B. 'admin'

C. nil

D. Raises an error

Solution

1. Step 1: Understand before_create callback

   The before_create callback runs the method set_default_role before the record is created in the database.

2. Step 2: Analyze set_default_role method

   The method sets self.role to 'guest' only if it is currently nil or falsey (using ||=).

3. Final Answer:

   'guest' -> Option A

4. Quick Check:

   before_create sets role to 'guest' if none set [OK]

Hint: before_create sets default values if none exist [OK]

Common Mistakes:

• Assuming role stays nil if not set
• Confusing before_create with after_create
• Thinking it raises an error without role

4. Identify the error in this callback definition:

class Post < ApplicationRecord
  before_save :check_title

  def check_title
    if title.blank?
      errors.add(:title, "can't be blank")
      throw :abort
    end
  end
end

medium

A. Using throw :abort is incorrect to stop save

B. No error, this is correct usage

C. Callback method should be private

D. errors.add should be errors.add_error

Solution

1. Step 1: Review callback usage

   The before_save callback runs check_title before saving.

2. Step 2: Check error handling

   Adding errors and using throw :abort is the correct way to stop saving if validation fails.

3. Final Answer:

   No error, this is correct usage -> Option B

4. Quick Check:

   throw :abort stops save correctly [OK]

Hint: Use throw :abort to halt save in callbacks [OK]

Common Mistakes:

• Thinking throw :abort is invalid
• Believing errors.add needs a different method
• Assuming callback methods must be private

5. You want to run a method log_update only after a record is updated but not created. Which callback should you use?

hard

A. before_save

B. after_save

C. after_update

D. before_update

Solution

1. Step 1: Understand callback timing

   after_save runs after both create and update, but after_update runs only after updates.

2. Step 2: Choose callback for updates only

   Since you want to run log_update only after updates, after_update is the correct choice.

3. Final Answer:

   after_update -> Option C

4. Quick Check:

   after_update runs only after updates [OK]

Hint: Use after_update for actions only after updates [OK]

Common Mistakes:

• Using after_save which runs on create too
• Choosing before_update which runs before update
• Confusing before_save with after_update