Build a minimal decorator with Ruby in 30 minutes

A few weeks ago, I needed to add some view-related methods to an object. Decorators are my go-to pattern to handle this kind of logic.

Normally, I’d use the draper gem to build decorators. But the app I’m working on used an older and incompatible version of Rails.

So I built a minimal decorator from scratch, added a bunch of extra behaviors, only to end up abstracting all of these away. Follow along!

What I’m working with

My Teacher class has a handful of methods:

• A one-to-many relationship with the Student class.
• Two public methods: one that exposes the maximum number of students a teacher can teach to, and one exposing the available teaching places.

  class Teacher < ApplicationRecord
    has_many :students

    def maximum_number_of_students = 30

    def available_places
      (maximum_number_of_students <=> students.size).clamp(0..)
    end
  end

In my views, I want to display a table of teachers where the number of available places for each teacher is backed by a background colour.

# teachers/index.html.erb

<table class="table table-striped">
  <thead>
    <tr>
      <th>Name of the teacher</th>
      <th>Available places</th>
    </tr>
  </thead>
  <tbody>
    <% teachers.each do |teacher| %>
      <tr>
        <td><%= teacher.full_name %></td>
        <td class="<%= teacher.colour_coded_availability %>">
            <%= teacher.available_places %>
        </td>
      </tr>
    <% end %>
  </tbody>
</table>

I could write the Teacher#colour_coded_availability method in my model like so:

  class Teacher < ApplicationRecord
    has_many :students

    def maximum_number_of_students = 30

    def available_places
      (maximum_number_of_students <=> students.size).clamp(0..)
    end

    def colour_coded_availability
      case available_places
      when 0 then "bg-colour-red"
      else "bg-colour-green"
      end
    end
  end

However, models are not the place for methods generating CSS classes. Decorators are!

Drafting a decorator

My decorator should accept an instance of Teacher and expose the colour_coded_availability public method.

# app/decorators/teacher_decorator.rb

  class TeacherDecorator
    attr_reader :teacher

    def initialize(teacher:)
      @teacher = teacher
    end

    def colour_coded_availability
      case teacher.available_places
      when 0 then "bg-colour-red"
      else "bg-colour-green"
      end
    end
  end

Now, I can instantiate my decorator and use it in my views:

# app/controllers/teachers_controller.rb
  class TeachersController < ApplicationController
    def index
      @teachers = Teacher.all.map { TeacherDecorator.new(teacher: _1) }
    end
  end

# teachers/index.html.erb
  <table class="table table-striped">
    <thead>
      <tr>
        <th>Name of the teacher</th>
        <th>Available places</th>
      </tr>
    </thead>
    <tbody>
      <% @teachers.each do |teacher| %>
        <tr>
          <td><%= teacher.full_name %></td>
          <td class="<%= teacher.colour_coded_availability %>">
              <%= teacher.available_places %>
          </td>
        </tr>
      <% end %>
    </tbody>
  </table>

When I can call teacher.colour_coded_availability in my views, the method retrieves a CSS class and adds it to the HTML <td> tag.

But if I were to run this code as is, I’d get a beautiful NoMethodError. Why?

My views do not handle instances of Teacher anymore. They handle instances of TeacherDecorator. So, when I’m calling the public methods defined on Teacher, the decorator doesn’t know what to do with them.

My decorator needs to be able to handle both its own public methods and the public methods defined on the underlying record (Teacher, in this case).

And we do that by using Ruby’s method_missing.

Ruby’s method_missing to the rescue

method_missing is how Ruby handles method calls made on objects where said methods are not defined. Ruby passes the method call along the ancestry chain until it can either resolves it or raises a NoMethodError.

When I call @teacher.full_name, I want my decorator to rescue the NoMethodError, and forward #full_name to the underlying instance of Teacher.

To do that, I need to re-open Ruby’s method_missing, add a custom behavior, then allow method_missing to run its normal course.

class TeacherDecorator
  attr_reader :teacher

  def initialize(teacher)
    @teacher = teacher
  end

  def availability_as_background
    case teacher.max_number_of_students <=> teacher.available_places
    when -1 then "background-danger"
    when 0 then "background-warning"
    when 1 then "background-success"
    end
  end

  private

  def method_missing(method, ...)
    return teacher.public_send(method, ...) if teacher.respond_to?(method)

    super
  end

  def respond_to_missing?(name, include_private = false)
    teacher.respond_to?(name) || super
  end
end

In this example, I keep the original signature of Ruby’s method_missing.

The only thing I tweak is forwarding the method call to the underlying teacher. I only forward it if the teacher responds to the method. Then, I let Ruby resume its original behavior ¹.

Now, @teacher.full_name is properly forwarded to the underlying instance of Teacher.

What would be cool now, is to allow other decorators to share this behavior.

Normalizing the behavior to create other decorators

One way to gather default behavior shared across various decorators is to rely on inheritance. I can create an ApplicationDecorator whose job is to handle instantiation, and forwarding method calls to the underlying record.

Then, I can have my TeacherDecorator inherit from the ApplicationDecorator.

class ApplicationDecorator
  def initialize(record)
    @record = record
  end

  private

  attr_reader :record

  def method_missing(method,...)
    if record.respond_to?(method)
      record.public_send(method, ...)
    else
      super
    end
  end

  def respond_to_missing?(name, include_private = false)
    record.respond_to?(name) || super
  end
end

class TeacherDecorator < ApplicationDecorator
  attr_reader :teacher

  def availability_as_background
    case teacher.max_number_of_students <=> teacher.available_places
    when -1 then "background-danger"
    when 0 then "background-warning"
    when 1 then "background-success"
    end
  end

  private

  alias_method :teacher, :record
end

My TeacherDecorator doesn’t need to bother about its initialization since it’s handled by the parent ApplicationDecorator. The only thing I added, is the ability to reference the record as teacher so it’s clearer what kind of record we’re working with.

Ensure Rails default behavior works well

Some Rails native helpers will have a hard time handling my decorator.

Consider this code:

  `edit_teacher_path(@teacher)` # => Should generate teachers/1/edit

But if @teacher references an instance of my TeacherDecorator, the generated path is teachers/#TeacherDecorator/edit.

How do I make my decorator integrate with Rails default behavior?

I can re-open the to_param method which is responsible for turning (among other things) a record into its id, and delegating its behavior to the record.

class ApplicationDecorator
  def initialize(record)
    @record = record
  end

  delegate :to_param, to: :record

  private

  attr_reader :record

  def method_missing(method,...)
    if record.respond_to?(method)
      record.public_send(method, ...)
    else
      super
    end
  end

  def respond_to_missing?(name, include_private = false)
    record.respond_to?(name) || super
  end
end

Of course, forwarding every Rails default behaviors to the underlying record is not a great strategy (too much complexity). So, how should I do it?

Use Ruby standard SimpleDelegator

SimpleDelegator provides the means to delegate all supported method calls to the object passed into the constructor.

This means that by using SimpleDelegator, I can remove the initialization and the delegation logics from my ApplicationDelegator.

require "delegate"

class ApplicationDecorator < SimpleDelegator ; end

Everything is abstracted away. And it just works™. @record is not available anymore for my TeacherDecorator to reference, but SimpleDelegator exposes a __getobj__ that works exactly as my previous @record ivar.

Final implementation

Here’s what I ended up with:

require "delegate"

class ApplicationDecorator < SimpleDelegator ; end

class TeacherDecorator < ApplicationDecorator
  def availability_as_background
    case teacher.max_number_of_students <=> teacher.available_places
    when -1 then "background-danger"
    when 0 then "background-warning"
    when 1 then "background-success"
    end
  end

  alias_method :teacher, :__getobj__
end

That’s it! A 30-minute minimal decorator in plain Ruby.

Cheers,

Rémi - @remi@ruby.social

PS: I'm available for hire.