Overview

In the RailsConf 2025 talk "Off the Rails: Validating non-model classes with…ActiveModel?", Andy Andrea discusses strategies and techniques for leveraging Rails' ActiveModel validation system for non-model classes such as Hashes, Structs, or Data instances. The talk is motivated by real-world scenarios where traditional Rails models are not used, including event-sourced applications with custom data layers.

Main Topic

The central theme of the talk is building a single, flexible validator class capable of running Rails validators—both built-in and custom—on arbitrary Ruby objects without the need for creating new ActiveModel classes for every data shape. The approach supports validating Hashes, non-ActiveRecord objects, value objects, and third-party classes without monkey patching.

Key Points

• Separation of Validation Logic in Rails:

  • Rails validators typically operate on model classes, registering validations at the class level and invoking them at the instance level.
  • There are challenges when the data to be validated isn't a traditional model (e.g., Hashes in event-sourced systems).

• Initial Proof of Concept:

  • Andrea demonstrates naïvely running the PresenceValidator against a Hash, highlighting immediate issues (missing methods like errors, read_attribute_for_validation, etc.).

• Creating a Wrapper to Simulate Models:

  • A wrapper class is introduced to handle method missing, provide required interfaces, and wrap arbitrary objects, thus enabling the use of ActiveModel validators on them.
  • SimpleDelegator and method_missing patterns are discussed to reliably delegate method calls or key lookups to the wrapped objects.

• Handling Validator Options:

  • Required logic for Rails options like allow_nil, allow_blank, if, and unless is implemented by ensuring that validator callbacks and ActiveSupport's callback system are observed.

• Supporting Conditionals and Dependencies:

  • The system supports conditionals by dynamically providing methods that correspond to keys in the Hash (e.g., supporting dependency in “validates presence of bad_jokes if Aaron”).

• Dealing with Mutability and State:

  • Addresses the issue of the underlying data mutating while being validated and ensures that the validator always references the current state.

• Extending Support for Additional Validators:

  • The solution is expanded to delegate all standard validator methods, handle custom validators, and manage edge cases like array validations and confirmation validators.

• Example Use Cases and Production Anecdote:

  • The primary use case shared is validating event objects in an event-sourced application where data are often Hashes or custom value objects with no model layer.
  • Practical caveats (such as data mutability during validation and validator state isolation) are discussed, with references to test-driven development and lessons from actual deployment.

Main Takeaways

• It's possible to use Ruby on Rails' powerful validation system outside of models by strategically wrapping any object (like a Hash) to meet ActiveModel expectations.
• This pattern enables flexible, reusable validation logic across various data shapes, reducing duplication and reliance on heavy model classes.
• The approach is suitable for event-sourced systems, incoming API validation, and any case where model-less data validation is needed.
• A reference implementation is available as a gem in the referenced repository, open to community use and extension.