4 key ingredients to trim Ruby on Rails models

We often encounter models burdened with excessive responsibilities in our Ruby on Rails applications. To address this, we've identified four essential tools: Concerns, Commands, Decorators, and ViewObjects. Here's an overview of each and how to use them to streamline your models.

Concerns: Modularizing Model Logic

Concerns are a way to encapsulate related methods and constants into modules. This makes them reusable across models. This tool is handy when you have cross-cutting concerns that affect multiple models.

For instance, if two models need tagging functionality, you can create a Taggable concern. The concern will then be used by all models requiring that functionality. This approach DRYs up your code and keeps the model focused on its responsibilities.

Commands: Clarifying Business Logic

Commands (or Service Objects) provide a procedural way to handle business operations. They are particularly effective when a task involves more than one model. It can also be helpful when the operation is complex enough to warrant its object.

The case of a user registration is quite a classic example. We must create a user, send a welcome email, and log the activity. A RegisterUser Command can encapsulate the entire process. This keeps your User model clean and focused solely on representing the user. The Command is focused on doing the actions. That's why they are often called Service Objects, Actors or Interactors.

Decorators: Separating Presentation Logic

If a Model is littered with presentation logic, Decorators are an excellent solution to move it out.

A first example would be displaying a formatted date in multiple views. Instead of adding a formatting method to the model, a method within a decorator can be used. This keeps the model’s focus on business and persistence logic.

Another example would be methods to format first and last names to display in views. In some cases, we want "John Doe"; in others, we might wish to "J. Doe", etc ... Well, this has nothing to do with the model. A decorator can do that very well.

Some might prefer to use Concerns for this. It also works.

ViewObjects: Streamlining Complex Views

ViewObjects are helpful with complex views requiring data from multiple models. They act as a façade, providing a single place to encapsulate all the logic and data retrieval needed for a view.

For instance, a dashboard displaying User, Order, and Product information can benefit from a DashboardViewObject. This approach simplifies the controller and view code by moving the complex data gathering and processing into a single, testable unit.

Integrating These Tools into Your Ruby on Rails Application

1. Identify the Suitable Patterns: Determine which patterns suit your application's needs. Not every pattern is needed in every scenario.
2. Proof of Concept: Conduct a small test or PoC to evaluate the pattern's effectiveness in your context before a full-scale implementation.
3. Documentation and Team Onboarding: Once a pattern is chosen, document its usage and onboard your team through technical articles, presentations, or design documents.
4. Pair Programming and Regular Check-ins: Encourage pair programming sessions for implementing these patterns and schedule regular check-ins to assess their impact.
5. Iterate and Adapt: Be open to implementing as your application and team evolve.

Conclusion: These four patterns provide robust tools for keeping Rails models manageable and responsibilities well-distributed. While this article introduces these patterns, their practical implementation requires experimentation and adaptation to your project needs.