Model-backed forms in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a model-backed form is submitted with invalid data?

Consider a Rails form built with form_with model: @user. If the user submits the form with invalid data that fails model validations, what is the typical behavior?

A The server crashes with an unhandled exception.

B The form clears all fields and redirects to the homepage without showing errors.

C The form submits successfully and saves the invalid data to the database.

D The form re-renders with error messages displayed, and the invalid data remains in the form fields.

💡 Hint

Think about how Rails handles validation failures in controller actions.

When a model-backed form submits invalid data, Rails typically re-renders the form view with the invalid data preserved and shows validation error messages. This helps users fix mistakes without losing their input.

📝 Syntax

intermediate

Which option correctly creates a model-backed form for a new Post?

Choose the correct Rails code snippet to create a form for a new Post model instance using form_with.

A <%= form_with model: @post, local: true do |form| %> ... <% end %>

B <%= form_with url: posts_path, method: :get do |form| %> ... <% end %>

C <%= form_with model: Post.new, remote: true do |form| %> ... <% end %>

D <%= form_for @post do |form| %> ... <% end %>

💡 Hint

Remember that form_with is the modern helper replacing form_for, and local: true disables AJAX.

Option A correctly uses form_with with a model instance and local: true to create a standard HTML form. Option A uses GET method which is not typical for creating records. Option A uses deprecated form_for. Option A uses a new model instance but enables remote AJAX submission.

❓ state_output

advanced

What is the value of @post.title after submitting the form with title 'Hello' but validation fails?

Given a Post model with a validation that title must be unique, and a form submits with title 'Hello' which already exists, what will @post.title be in the controller after @post.update(post_params) fails?

Ruby on Rails

def update
  @post = Post.find(params[:id])
  if @post.update(post_params)
    redirect_to @post
  else
    render :edit
  end
end

A The original title before update

B nil

C 'Hello'

D Raises an error

💡 Hint

Think about how Rails assigns attributes before validation.

When @post.update(post_params) is called, Rails assigns the new attributes before validation. Even if validation fails, @post.title holds the attempted new value 'Hello'.

🔧 Debug

advanced

Why does the form not show validation errors after submission?

A developer uses form_with model: @article but after submitting invalid data, the form reloads without showing any error messages. What is the most likely cause?

A The controller action does not re-render the form view on validation failure.

B The model has no validations defined.

C The form uses <code>form_with</code> without a block.

D The form is missing the <code>authenticity_token</code>.

💡 Hint

Check what the controller does when saving fails.

If the controller redirects instead of re-rendering the form view on validation failure, the errors and invalid data are lost. The form then shows no errors.

🧠 Conceptual

expert

How does Rails link form fields to model attributes in model-backed forms?

In a Rails model-backed form, how does Rails know which form input corresponds to which model attribute when the form is submitted?

A Rails matches input <code>id</code> attributes to model attribute names automatically.

B Rails uses the <code>name</code> attribute of inputs, formatted as <code>model_name[attribute]</code>, to map submitted data to model attributes.

C Rails uses JavaScript to bind inputs to model attributes dynamically at runtime.

D Rails relies on the order of inputs in the form to assign values to model attributes.

💡 Hint

Think about how HTML form data is structured and sent to the server.

Rails generates input name attributes like post[title]. When the form submits, parameters are nested hashes matching model attributes. This lets Rails assign values correctly.

Practice

1. What is the main advantage of using form_with model: @model in Rails?

easy

A. It creates a form without any connection to the database.

B. It automatically links the form to the model for easy data handling.

C. It disables form validations for faster submission.

D. It generates a plain HTML form without Rails helpers.

Solution

1. Step 1: Understand model-backed forms

   Model-backed forms connect the form fields directly to the model's attributes, simplifying data handling.

2. Step 2: Recognize the role of form_with model: @model

   This helper automatically binds the form to the model instance, enabling validations and error messages.

3. Final Answer:

   It automatically links the form to the model for easy data handling. -> Option B

4. Quick Check:

   Model-backed forms = automatic model connection [OK]

Hint: Remember: model option links form to data model directly [OK]

Common Mistakes:

• Thinking it creates a form without database connection
• Assuming validations are disabled
• Confusing it with plain HTML forms

2. Which of the following is the correct syntax using form_with to create a model-backed form for a @post object in Rails?

easy

A. form_with url: posts_path do |form|

B. form_for @post do |form|

C. form_with model: @post do |form|

D. form_tag @post do |form|

Solution

1. Step 1: Identify the modern Rails form helper

   Rails 5.1+ recommends form_with for forms, replacing older helpers.

2. Step 2: Use the model option for model-backed forms

   Using model: @post binds the form to the @post instance for automatic attribute handling.

3. Final Answer:

   form_with model: @post do |form| -> Option C

4. Quick Check:

   Correct syntax uses form_with + model option [OK]

Hint: Use form_with with model: @object for model forms [OK]

Common Mistakes:

• Using form_tag which is for non-model forms
• Using form_for which is deprecated
• Using url option instead of model for model forms

3. Given the following code snippet, what will be the rendered HTML input name attribute for the title field?

form_with model: @article do |form|
  form.text_field :title
end

medium

A. article[title]

B. title

C. article_title

D. form[title]

Solution

1. Step 1: Understand Rails naming conventions for model-backed forms

   Rails uses the model name as a prefix in input names to group attributes, e.g., modelname[field].

2. Step 2: Apply to the given example

   For model @article and field :title, the input name becomes article[title] to map params correctly.

3. Final Answer:

   article[title] -> Option A

4. Quick Check:

   Input name = model[field] format [OK]

Hint: Input names use model[field] format in model-backed forms [OK]

Common Mistakes:

• Using just the field name without model prefix
• Combining model and field with underscore
• Using form as prefix instead of model name

4. Identify the error in this model-backed form code snippet:

form_with model: @user do |form|
  form.text_field :email
  form.submit
end

The form does not display validation errors when the email is invalid. Why?

medium

A. The form_with helper does not support model-backed forms.

B. The form does not include form.error_messages to show errors.

C. The form is missing local: true to enable validations.

D. The model @user lacks validations on the email attribute.

Solution

1. Step 1: Check if form_with supports model-backed forms

   form_with fully supports model-backed forms and validations automatically.

2. Step 2: Verify model validations

   If validation errors do not show, likely the model @user does not have validations defined for email.

3. Final Answer:

   The model @user lacks validations on the email attribute. -> Option D

4. Quick Check:

   Missing model validations = no errors shown [OK]

Hint: Validation errors need model validations defined [OK]

Common Mistakes:

• Assuming form_with needs local: true for validations
• Expecting form.error_messages helper to exist
• Thinking form_with can't handle model forms

5. You want to create a nested model-backed form where a Project has many Tasks. Which approach correctly handles nested attributes in the form?

hard

A. Use form_with model: @project and inside use form.fields_for :tasks to build task fields.

B. Use separate form_with for @project and each @task without nesting.

C. Use form_tag with manual input names for tasks.

D. Use form_with model: @task only, ignoring the project.

Solution

1. Step 1: Understand nested model forms in Rails

   Rails supports nested attributes allowing a parent model form to include child model fields.

2. Step 2: Use fields_for inside form_with

   To handle nested tasks inside a project form, use form.fields_for :tasks to generate fields for each task.

3. Final Answer:

   Use form_with model: @project and inside use form.fields_for :tasks to build task fields. -> Option A

4. Quick Check:

   Nested forms use fields_for inside form_with [OK]

Hint: Use fields_for inside form_with for nested models [OK]

Common Mistakes:

• Creating separate forms instead of nested
• Using form_tag which lacks model binding
• Ignoring parent model in nested forms