Model-backed forms in Ruby on Rails - Step-by-Step Execution

Concept Flow - Model-backed forms

User opens form page

↓

Rails controller action

↓

Create new model instance

↓

Render form with model data

↓

User fills form and submits

↓

Controller receives params

↓

Assign params to model

↓

Validate model

↓

Save model

↓

Redirect or render success

This flow shows how Rails uses a model instance to build a form, receive user input, validate, and save or show errors.

Execution Sample

Ruby on Rails

class UsersController < ApplicationController
  def new
    @user = User.new
  end

  def create
    @user = User.new(user_params)
    if @user.save
      redirect_to root_path
    else
      render :new
    end
  end

  private

  def user_params
    params.require(:user).permit(:name, :email, :password, :password_confirmation)
  end
end

This code creates a new user form and handles form submission, saving the user if valid or re-rendering the form with errors.

Execution Table

Step	Action	Model State (@user)	Validation Result	Next Step
1	User visits /users/new	User instance created, empty attributes	Not validated yet	Render form with empty fields
2	User fills form and submits	User instance with submitted attributes	Validation runs	If valid, save; else show errors
3	Validation passes	User instance valid	Valid	Save user to database, redirect to root_path
4	Validation fails	User instance invalid with errors	Invalid	Render :new template with error messages
5	Redirect or render completes	User saved or form re-rendered	N/A	End of request

💡 Request ends after redirect on success or re-render on validation failure

Variable Tracker

Variable	Start	After Step 2	After Step 3 or 4	Final
@user	new empty User instance	User instance with form data	Saved User or User with errors	Saved User or form re-rendered with errors

Key Moments - 2 Insights

Why does the form re-render with errors instead of redirecting when validation fails?

Because in step 4 the controller calls render :new to keep the @user object with errors, allowing the form to show error messages without losing user input.

What happens if we call redirect instead of render when validation fails?

Redirecting would create a new request and lose the @user object and its errors, so the form would not show validation messages or preserve user input.

Visual Quiz - 3 Questions

Look at the execution table, what is the @user state after step 2?

A User instance with submitted attributes

B Empty User instance

C Saved User in database

D User instance with errors

💡 Hint

Check the 'Model State (@user)' column in row for step 2

At which step does the controller decide to save the user or show errors?

A Step 1

B Step 2

C Step 3 or 4

D Step 5

💡 Hint

Look at the 'Validation Result' and 'Next Step' columns for steps 3 and 4

If the validation fails, what does the controller do next?

A Redirect to root_path

B Render the new form with errors

C Save the user anyway

D Raise an exception

💡 Hint

See step 4 in the 'Next Step' column

Concept Snapshot

Model-backed forms in Rails:
- Controller creates a model instance (@user = User.new)
- Form helpers bind to @user for fields
- On submit, controller assigns params to @user
- Validate with @user.save (returns true/false)
- If valid, save and redirect
- If invalid, render form with errors to show messages

Full Transcript

Model-backed forms in Rails start when the user visits a form page. The controller creates a new model instance, like @user = User.new, and renders the form with this object. The form fields are linked to the model's attributes. When the user submits the form, the controller receives the parameters and assigns them to a new model instance. It then tries to save the model, which runs validations. If validations pass, the model is saved to the database and the user is redirected. If validations fail, the form is re-rendered with error messages, preserving the user's input. This flow ensures user input is validated and feedback is shown clearly.