Custom validation methods in Ruby on Rails - Deep Dive

Overview - Custom validation methods

What is it?

Custom validation methods in Rails let you create your own rules to check if data is correct before saving it. Instead of only using built-in checks, you write a method that runs when saving a record. This method can add errors if the data does not meet your special conditions. It helps keep your app's data clean and meaningful.

Why it matters

Without custom validations, you would be stuck with only the default checks Rails provides, which might not fit your app's unique needs. This could lead to wrong or incomplete data in your database, causing bugs or bad user experiences. Custom validations let you enforce your own rules, making your app more reliable and trustworthy.

Where it fits

Before learning custom validations, you should understand basic Rails models and built-in validations like presence or uniqueness. After mastering custom validations, you can explore advanced topics like conditional validations, validation callbacks, and form object validations.

Mental Model

Core Idea

Custom validation methods are like personalized gatekeepers that check your data against your own rules before it enters the database.

Think of it like...

Imagine a club with a bouncer who checks if guests meet special dress codes or membership rules before letting them in. Custom validation methods are the bouncer enforcing your unique rules.

┌─────────────────────────────┐
│        Model Object         │
│  ┌─────────────────────┐   │
│  │ Custom Validation    │◄──┤
│  │ Method Checks Data   │   │
│  └─────────────────────┘   │
│           │                 │
│           ▼                 │
│  ┌─────────────────────┐   │
│  │ Adds Errors if Fail │   │
│  └─────────────────────┘   │
└─────────────┬──────────────┘
              │
              ▼
       Save Allowed or Not

Build-Up - 7 Steps

1

Foundation

What are validations in Rails

Concept: Introduces the idea of validations as checks that run before saving data.

Rails models use validations to ensure data is correct. For example, `validates :name, presence: true` checks that the name is not empty. These built-in validations help keep data clean.

Result

Data that fails validations will not save, and errors will be available to show to users.

Understanding built-in validations is essential because custom validations build on this concept to handle special cases.

2

Foundation

How to add errors in Rails models

Concept: Shows how to manually add error messages to a model's errors collection.

Inside a model, you can add errors like `errors.add(:attribute, 'message')`. This tells Rails the data is invalid for that attribute with a custom message.

Result

When errors are added, the model is considered invalid and will not save.

Knowing how to add errors manually is the core mechanism behind custom validations.

3

Intermediate

Writing a simple custom validation method

🤔Before reading on: do you think a custom validation method runs automatically or needs to be called explicitly? Commit to your answer.

Concept: Explains how to define a method and tell Rails to use it as a validation.

Define a method in your model, for example `check_age`, that adds errors if conditions fail. Then use `validate :check_age` to run it automatically before saving.

Result

Rails runs your method during validation, and if errors are added, saving is blocked.

Understanding that `validate` hooks your method into Rails' validation process is key to making custom checks work.

4

Intermediate

Using conditional logic in custom validations

🤔Before reading on: can custom validations run only sometimes based on other data? Commit to yes or no.

Concept: Shows how to run validations only when certain conditions are met.

Inside your custom method, use `if` or `unless` to check other attributes or states before adding errors. You can also use `validate :method, if: :condition_method` to run validations conditionally.

Result

Validations become flexible and only run when needed, avoiding unnecessary errors.

Knowing how to control when validations run helps build smarter, user-friendly checks.

5

Intermediate

Validating multiple attributes together

🤔Before reading on: do you think custom validations can check relationships between attributes? Commit to yes or no.

Concept: Demonstrates how to validate combinations of fields in one method.

In your custom method, you can check multiple attributes at once, for example ensuring `start_date` is before `end_date`. Add errors to one or both attributes as needed.

Result

You can enforce complex rules that depend on several pieces of data working together.

Understanding multi-attribute validation unlocks powerful data integrity rules.

6

Advanced

Reusing custom validations with modules

🤔Before reading on: do you think custom validation methods can be shared across models? Commit to yes or no.

Concept: Shows how to extract validation logic into modules for reuse.

Create a module with your validation method and include it in multiple models. This avoids repeating code and keeps validations consistent.

Result

Your app stays DRY (Don't Repeat Yourself) and easier to maintain.

Knowing how to share validations improves code quality and teamwork.

7

Expert

Performance and pitfalls of custom validations

🤔Before reading on: do you think complex custom validations can slow down saving records? Commit to yes or no.

Concept: Explores how heavy validation logic affects app speed and how to avoid common mistakes.

Custom validations run every time a record is saved or validated. Complex queries or slow code inside them can degrade performance. Use caching, avoid database calls inside validations, and keep logic simple.

Result

Your app remains responsive and scalable even with custom validations.

Understanding performance tradeoffs prevents slowdowns and bugs in production.

Under the Hood

When you call `save` or `valid?` on a Rails model, it triggers the validation process. Rails collects all validation methods, including built-in and custom ones registered with `validate`. It runs each method in order. If a method adds errors to the model's `errors` collection, the model is marked invalid and saving stops. The errors are then accessible for display or logging.

Why designed this way?

Rails uses this design to keep validations flexible and extensible. Built-in validations cover common cases, but apps often need special rules. Allowing custom methods lets developers write any logic they want. The `errors` collection centralizes error handling, making it easy to show messages to users. This approach balances simplicity with power.

┌───────────────┐
│ Call save/valid?│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Gather validations │
│ (built-in + custom)│
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Run each validation │
│ method in order     │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Add errors if invalid │
└──────┬────────┘
       │
       ▼
┌───────────────┐
│ Model valid?   │
│ Yes → save    │
│ No → reject   │
└───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does adding errors in a custom validation always stop the record from saving? Commit to yes or no.

Common Belief: Adding errors in a custom validation always prevents saving the record.

Reality: Errors only prevent saving if the validation runs during `save` or `valid?`. If you add errors outside validation callbacks, they might not block saving.

Why it matters: Assuming errors always block saving can lead to bugs where invalid data is saved unexpectedly.

Quick: Can custom validations access the database safely without performance issues? Commit to yes or no.

Common Belief: It's fine to query the database inside custom validation methods.

Reality: Database queries inside validations can cause slowdowns and unexpected side effects, especially if validations run multiple times.

Why it matters: Ignoring this can make your app slow and cause hard-to-debug performance problems.

Quick: Do custom validations run automatically on every attribute change? Commit to yes or no.

Common Belief: Custom validations run only when the attributes they check change.

Reality: Custom validations run every time the model is validated, regardless of which attributes changed.

Why it matters: This can cause unnecessary validation runs and performance hits if not managed carefully.

Quick: Can you use `validates` with a custom method name directly? Commit to yes or no.

Common Belief: You can write `validates :attribute, custom_method: true` to use a custom validation method.

Reality: Custom validations require `validate :method_name`, not `validates` with a method name.

Why it matters: Confusing these leads to validations not running and data errors slipping through.

Expert Zone

1

Custom validations can be combined with ActiveModel::EachValidator to create reusable validator classes for complex logic.

2

Using `validate` with method names allows multiple validations per model, but order matters when validations depend on each other.

3

Custom validations can be skipped or conditionally run using `if` and `unless` options, which is crucial for performance and correctness in complex forms.

When NOT to use

Avoid custom validations when a built-in validation or database constraint can enforce the rule more efficiently. For example, use `validates_uniqueness_of` or database unique indexes instead of custom uniqueness checks. Also, avoid heavy database queries inside validations; use background jobs or service objects for complex checks.

Production Patterns

In production Rails apps, custom validations are often extracted into separate validator classes or modules for reuse. They are combined with conditional options to run only when needed. Developers also write tests specifically for custom validations to ensure data integrity. Performance monitoring is used to detect slow validations.

Connections

Database Constraints

complementary

Understanding database constraints alongside custom validations helps ensure data integrity both at the app and database level, preventing invalid data even if validations are bypassed.

Design by Contract (Software Engineering)

similar pattern

Custom validations act like contracts that data must fulfill before proceeding, similar to how design by contract enforces conditions in software components.

Quality Control in Manufacturing

analogous process

Just as quality control checks products against standards before shipping, custom validations check data against rules before saving, ensuring only good data enters the system.

Common Pitfalls

#1 Adding database queries inside custom validation methods causing slow saves.

Wrong approach:

def check_unique_email
if User.where(email: email).exists?
errors.add(:email, 'has already been taken')
end
end
validate :check_unique_email

Correct approach:

validates :email, uniqueness: true

Root cause:

Misunderstanding that Rails provides built-in uniqueness validation optimized for this, and that querying inside validations can cause performance issues.

#2 Using `validates` instead of `validate` for custom methods, so validations never run.

Wrong approach:

validates :check_age

Correct approach:

validate :check_age

Root cause:

Confusing the `validates` macro (for built-in validations) with `validate` (for custom methods).

#3 Adding errors outside validation context, expecting save to fail.

Wrong approach:

def some_method
errors.add(:base, 'error')
end
# called outside validation callbacks

Correct approach:

validate :some_method

Root cause:

Not understanding that errors must be added during validation callbacks to affect saving.

Key Takeaways

Custom validation methods let you write your own rules to check data before saving in Rails.

They work by defining a method that adds errors to the model if data is invalid, and hooking it with `validate`.

Custom validations run every time the model is validated, so keep them efficient and avoid heavy database queries inside.

Use conditional options to run validations only when needed, improving performance and user experience.

Knowing when to use built-in validations, database constraints, or custom methods is key to building reliable Rails apps.