Format validation in Ruby on Rails - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a Rails model with format validation receives invalid input?

Consider a Rails model with this validation:

validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/, message: "must be a valid email" }

What will be the state of the model after assigning user.email = "invalid-email" and calling user.valid??

Ruby on Rails

class User < ApplicationRecord
  validates :email, format: { with: /\A[^@\s]+@[^@\s]+\z/, message: "must be a valid email" }
end

user = User.new
user.email = "invalid-email"
valid = user.valid?

A The model is valid; errors will be empty because format validation only checks presence.

B The model is valid; format validation ignores invalid emails without @ symbol.

C The model raises a runtime error due to invalid regex in validation.

D The model is invalid; user.errors will include "email must be a valid email".

💡 Hint

Think about what happens when the input does not match the regex pattern.

The format validation checks if the email matches the regex. Since "invalid-email" lacks an @ symbol, it fails the regex, making the model invalid and adding an error message.

📝 Syntax

intermediate

Which format validation syntax is correct in Rails?

You want to validate that a username contains only letters and numbers. Which of these validations is syntactically correct?

A validates :username, format: { regex: /\A[a-zA-Z0-9]+\z/ }

B validates_format_of :username, with: /\A[a-zA-Z0-9]+\z/, message: 'only letters and numbers allowed'

C validates :username, format: { with: /\A[a-zA-Z0-9]+\z/ }

D validates :username, format: /\A[a-zA-Z0-9]+\z/

💡 Hint

Check the correct key name inside the format hash.

The correct syntax uses the :with key inside the format hash. Option C uses this correctly. Option C misses the hash, C uses deprecated method, and A uses wrong key :regex.

🔧 Debug

advanced

Why does this format validation not work as expected?

Given this model validation:

validates :phone, format: { with: /\d{3}-\d{3}-\d{4}/ }

Why might a phone number like "123-456-7890" still be invalid?

A The regex is missing start (\A) and end (\z) anchors, so it matches substrings but validation expects full match.

B The regex lacks anchors, so partial matches pass, but full string match is required.

C The regex is correct; the problem is the phone attribute is nil.

D The format validation requires the regex to be a string, not a Regexp object.

💡 Hint

Think about how Rails uses the regex to validate the entire attribute string.

Rails format validation requires the regex to match the entire string. Without \A and \z anchors, the regex matches substrings, causing validation to fail if the whole string doesn't match.

❓ state_output

advanced

What is the value of errors after invalid format validation?

Given this code:

class User < ApplicationRecord
  validates :zip_code, format: { with: /\A\d{5}\z/, message: 'must be 5 digits' }
end

user = User.new(zip_code: '1234a')
user.valid?
errors = user.errors[:zip_code]

What is the value of errors?

A ["must be 5 digits"]

B ["is invalid"]

C []

D nil

💡 Hint

Check the custom message in the validation.

Since '1234a' does not match the 5-digit regex, validation fails and the custom message 'must be 5 digits' is added to errors[:zip_code].

🧠 Conceptual

expert

Why use format validation instead of custom validation method in Rails?

Which is the main advantage of using validates :attribute, format: { with: /regex/ } over writing a custom validate :method_name method for format checking?

A Format validation allows multiple regex patterns at once, custom methods do not.

B Format validation integrates automatically with Rails error messages and helpers, reducing boilerplate code.

C Custom validation methods cannot add errors to the model.

D Custom validation methods run faster than format validations.

💡 Hint

Think about how Rails helpers and error messages work with built-in validations.

Using format validation leverages Rails built-in features like automatic error message generation and integration with form helpers, making code simpler and more consistent.