When you dive into building web applications with Ruby on Rails, the name of the game is keeping your code clean, readable, and maintainable. One gem that steps up to help with this is Draper. Draper lets you wrap your models with presentation logic, making your views and controllers lean, mean, organized machines.

So, what exactly is Draper?

Draper is a gem that uses the Decorator pattern to add extra functionality to an object without changing its structure. This approach lets you keep your models focused on business logic, your controllers on handling requests and responses, and moves all that display-related logic to decorators where it belongs.

Now, how to get started with Draper?

First off, you need to add Draper to your Rails application’s Gemfile:

gem 'draper'

Then, a quick bundle install will get it set up. Once that’s done, you’ll usually put your decorators in the app/decorators folder. Suppose you’ve got a Post model, here’s what you’d do:

# app/decorators/post_decorator.rb
class PostDecorator < Draper::Decorator
  delegate_all

  def formatted_title
    "<h2>#{title}</h2>".html_safe
  end
end

In this setup, delegate_all makes sure all methods in the Post model are accessible through the decorator. The formatted_title method, for example, is solely for presentation, sprucing up the title of the post.

Alright, but how do you use decorators in your controllers and views?

It’s pretty straightforward. You need to decorate the model instance before sending it to the view:

# app/controllers/posts_controller.rb
class PostsController < ApplicationController
  def show
    @post = Post.find(params[:id]).decorate
  end
end

Then, in your view, you can call methods defined in the decorator:

<!-- app/views/posts/show.html.erb -->
<%= @post.formatted_title %>
<p><%= @post.content %></p>

Using decorators keeps your views focused on presentation while the decorator takes care of formatting logic.

Now, what if you need to decorate collections? Draper’s got you covered:

# Decorating a collection
decorated_posts = PostDecorator.decorate_collection(Post.all)
# or
decorated_posts = Post.all.decorate

This lets you apply presentation logic to multiple objects at once without breaking a sweat.

Testing your decorators is also a breeze. Draper integrates seamlessly with testing frameworks like RSpec, MiniTest::Rails, and Test::Unit. When you create a decorator, Draper even generates corresponding tests. Here’s a quick peek at what that looks like with RSpec:

# spec/decorators/post_decorator_spec.rb
require 'spec_helper'

describe PostDecorator do
  let(:post) { Post.new(title: 'Example Post', content: 'This is an example post.') }
  let(:decorated_post) { post.decorate }

  it 'formats the title' do
    expect(decorated_post.formatted_title).to eq("<h2>Example Post</h2>")
  end
end

You might also need to pass extra data to your decorators. Draper’s context hash feature comes in handy here:

# Passing context to a decorator
decorated_post = Post.first.decorate(context: { role: :admin })

And if you need to handle associations, you can decorate them and pass context too:

# app/decorators/post_decorator.rb
class PostDecorator < Draper::Decorator
  decorates_association :comments, context: { foo: "bar" }
end

This flexibility means Draper can handle complex presentation logic that depends on additional context.

So, what’s the scoop on the pros and cons of using Draper?

Pros:

• Cleaner Code: Moving presentation logic out of models and controllers keeps things organized.
• Testability: Draper makes it simpler to test presentation logic independently.
• Flexibility: You can decorate single objects and collections and pass context when needed.

Cons:

• Complexity: An extra gem can add to your application’s complexity.
• Compatibility: Draper’s had some bumps, especially with newer Rails versions like Rails 5.
• Maintenance: The Draper project doesn’t currently have a maintainer, which could lead to problems with bugs and updates down the line.

If you decide to go with Draper, some best practices to keep in mind are:

• Keep Decorators Thin: Don’t overload your decorators with too much logic. Keep them focused on presentation.
• Use Context Wisely: Pass only necessary data to your decorators.
• Test Thoroughly: Make sure your decorators have comprehensive tests to catch any issues early.

Draper is an awesome tool for keeping your Ruby on Rails application neat and maintainable. By wrapping your models with presentation logic, you ensure that your views and controllers stay lean and focused on their jobs. Draper fits well with different testing frameworks and offers a clean way to manage complex presentation tasks. By following best practices and being aware of its pros and cons, you can use Draper to streamline your Rails applications and keep them running smoothly.