Form object pattern in Ruby on Rails - Step-by-Step Execution

Concept Flow - Form object pattern

User submits form data

↓

Form Object receives data

↓

Validate data in Form Object

↓

Save or update

↓

Update underlying models

↓

Return success or failure

The form object receives user input, validates it, and if valid, updates one or more models; otherwise, it returns errors.

Execution Sample

Ruby on Rails

class SignupForm
  include ActiveModel::Model
  attr_accessor :email, :password

  validates :email, presence: true, format: { with: /\A[^@\s]+@[^@\s]+\z/ }
  validates :password, presence: true, length: { minimum: 6 }

  def save
    return false unless valid?
    User.create(email: email, password: password)
  end
end

This form object collects email and password, validates them, and creates a User if valid.

Execution Table

Step	Action	Input Data	Validation Result	Model Interaction	Output
1	Initialize SignupForm	{email: '[e-mail]', password: 'secret'}	N/A	N/A	Form object created with data
2	Call save method	Form data present	Check validations	N/A	Validations run
3	Validation passes?	email and password valid	Yes	N/A	Proceed to create User
4	Create User model	email and password	N/A	User record created	User instance returned
5	Return from save	User created	N/A	N/A	User instance returned
6	If validation failed	invalid data	No	N/A	Return false and errors

💡 Execution stops after save returns user instance or false depending on validation and model creation

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 4	Final
email	nil	'[e-mail]'	'[e-mail]'	'[e-mail]'	'[e-mail]'
password	nil	'secret'	'secret'	'secret'	'secret'
valid?	N/A	N/A	true	true	true
User instance	nil	nil	nil	User object created	User object created
save return	nil	nil	nil	User object created	User object created

Key Moments - 3 Insights

Why does the form object validate data before creating the User?

The form object runs validations first (see step 3 in execution_table). If validations fail, it stops and returns errors without creating a User (step 6). This prevents bad data from saving.

How does the form object handle multiple models?

Though this example shows one model, the form object can update many models inside the save method after validation (step 4). It acts as a coordinator for complex form data.

What happens if save returns false?

If validations fail, save returns false (step 6). The controller or caller can then show errors to the user without saving anything.

Visual Quiz - 3 Questions

Look at the execution_table at step 3, what happens if validation fails?

A The User model is created anyway

B The form object retries validation

C The save method returns false and stops

D The form object ignores errors

💡 Hint

Check step 6 in execution_table where validation fails and save returns false

According to variable_tracker, what is the value of 'valid?' after step 2?

A true

B false

C nil

D undefined

💡 Hint

Look at the 'valid?' row under 'After Step 2' column in variable_tracker

If the form object handled two models, how would the execution_table change?

A Validation would be skipped

B There would be multiple model creation steps after validation

C The form object would not return any output

D The form object would only update one model

💡 Hint

Refer to key_moments about handling multiple models inside save method

Concept Snapshot

Form Object Pattern in Rails:
- Create a plain Ruby class including ActiveModel::Model
- Define attributes with attr_accessor
- Add validations inside the form object
- Implement a save method that validates and updates one or more models
- Returns true on success, false on failure with errors
- Helps manage complex forms involving multiple models cleanly

Full Transcript

The Form Object pattern in Rails helps manage complex form data by creating a separate class that collects input, validates it, and updates one or more models. When a user submits a form, the form object receives the data and runs validations. If the data is valid, it creates or updates the underlying models and returns success. If not, it returns errors without saving. This pattern keeps controllers and models simpler by moving form logic into its own object. The example shows a SignupForm class that takes email and password, validates them, and creates a User if valid. The execution table traces each step from initialization, validation, model creation, to returning success or failure. Variable tracking shows how data changes through the process. Key moments clarify why validation happens first, how multiple models can be handled, and what happens on failure. The visual quiz tests understanding of validation flow, variable states, and handling multiple models. This pattern improves code organization and makes complex forms easier to maintain.

Practice

1. What is the main purpose of using a Form Object in Rails?

easy

A. To speed up database queries

B. To replace ActiveRecord models completely

C. To separate form validation and logic from database models

D. To generate HTML forms automatically

Solution

1. Step 1: Understand the role of form objects

   Form objects are used to keep form-related logic and validations separate from the database models.

2. Step 2: Compare with other options

   They do not replace ActiveRecord models or speed up queries, nor do they generate HTML forms automatically.

3. Final Answer:

   To separate form validation and logic from database models -> Option C

4. Quick Check:

   Form object purpose = Separation of form logic [OK]

Hint: Form objects separate form logic from models [OK]

Common Mistakes:

• Thinking form objects replace database models
• Assuming form objects speed up queries
• Confusing form objects with view helpers

2. Which module is commonly included in a Rails form object to provide model-like behavior?

easy

A. ActiveModel::Model

B. ActiveRecord::Base

C. ActionController::Base

D. ActiveSupport::Concern

Solution

1. Step 1: Identify the module for model-like behavior without DB

   The ActiveModel::Model module allows plain Ruby objects to behave like ActiveRecord models, including validations.

2. Step 2: Eliminate other options

   ActiveRecord::Base is for database models, ActionController::Base is for controllers, and ActiveSupport::Concern is for mixins.

3. Final Answer:

   ActiveModel::Model -> Option A

4. Quick Check:

   Form object module = ActiveModel::Model [OK]

Hint: Form objects include ActiveModel::Model for validations [OK]

Common Mistakes:

• Using ActiveRecord::Base in form objects
• Confusing controller modules with model modules
• Forgetting to include any module

3. Given this form object code, what will user_form.valid? return if email is blank?

class UserForm
  include ActiveModel::Model
  attr_accessor :email
  validates :email, presence: true
end

user_form = UserForm.new(email: '')
user_form.valid?

medium

A. true

B. false

C. nil

D. Raises an error

Solution

1. Step 1: Check validation rules

   The form object requires email to be present (not blank).

2. Step 2: Evaluate given input

   The email is an empty string, which fails the presence validation, so valid? returns false.

3. Final Answer:

   false -> Option B

4. Quick Check:

   Blank email fails presence validation = false [OK]

Hint: Presence validation fails on blank string [OK]

Common Mistakes:

• Assuming blank string passes presence validation
• Expecting valid? to raise error on blank
• Confusing nil and empty string behavior

4. Identify the error in this form object code:

class OrderForm
  include ActiveModel::Model
  attr_accessor :quantity
  validates :quantity, numericality: { greater_than: 0 }

  def save
    if valid?
      Order.create(quantity: quantity)
    end
  end
end

medium

A. Missing return value in save method

B. Order model is not defined

C. quantity is a string, needs conversion before validation

D. No error, code is correct

Solution

1. Step 1: Verify syntax and structure

   The code properly includes ActiveModel::Model, defines attr_accessor, and sets up numericality validation. Syntax is valid.

2. Step 2: Confirm behavior

   Numericality validation internally handles string-to-number conversion (e.g., '5' validates as > 0). The save method returns the Order instance (truthy) on success or nil/falsey otherwise, which works in conditionals.

3. Final Answer:

   No error, code is correct -> Option D

4. Quick Check:

   Numericality handles strings; save pattern acceptable [OK]

Hint: Rails numericality validator handles numeric strings automatically [OK]

Common Mistakes:

• Thinking strings need manual conversion for numericality
• Overthinking save method's return value
• Assuming undefined models cause errors in examples

5. You want to create a form object that handles user registration with email, password, and password_confirmation. Which approach correctly ensures password confirmation validation and saves the user if valid?

class RegistrationForm
  include ActiveModel::Model
  attr_accessor :email, :password, :password_confirmation

  validates :email, presence: true
  validates :password, presence: true, confirmation: true

  def save
    if valid?
      User.create(email: email, password: password)
    end
  end
end

hard

A. This code correctly validates and saves the user with password confirmation

B. Missing manual check for password_confirmation equality

C. Should use validates_confirmation_of :password_confirmation instead

D. Must call super in save method to save user

Solution

1. Step 1: Check validations for password confirmation

   The confirmation: true option on password automatically validates that password_confirmation matches.

2. Step 2: Verify save method logic

   The save method calls valid? and creates the user if valid, which is the correct pattern.

3. Final Answer:

   This code correctly validates and saves the user with password confirmation -> Option A

4. Quick Check:

   Password confirmation validation works with confirmation: true [OK]

Hint: Use confirmation: true for password confirmation validation [OK]

Common Mistakes:

• Manually checking password_confirmation equality
• Using deprecated validates_confirmation_of syntax
• Forgetting to call valid? before save