How to Implement an Enumerated Type in Rails

Have you ever wanted to use an enumerated type in your Rails app? After years of feature requests, Rails 4.1 finally added them: a simple implementation that maps strings to integers. But what if you need something different?

On a recent project, I implemented a survey, where animals are matched by answering a series of multiple-choice questions. The models looked like this:

class Animal < ActiveRecord::Base
  has_many :answer_keys
end

class AnswerKey < ActiveRecord::Base
  belongs_to :animal

  validates :color, :hair_length, presence: true
end

An animal has many answer keys, where an answer key is a set of survey answers that matches that animal. color and hair_length each represent a multiple-choice answer and are natural candidates for an enum.

The simplest possible implementation might look like this:

validates :color,       inclusion: { in: %w(black brown gray orange yellow white) }
validates :hair_length, inclusion: { in: %w(less_than_1_inch 1_to_3_inches longer_than_3_inches) }

However, there were additional requirements for each of these enums:

• Convert the value to a human readable name, for display in the admin interface
• Export all of the values and their human names to JSON, for consumption and display by a mobile app

Currently, the enum values are strings; what I really need is an object that looks like a string but has some custom behavior. A subclass of String should do nicely:

module Survey
  class Enum < String
    # Locale scope to use for translations
    class_attribute :i18n_scope

    # Array of all valid values
    class_attribute :valid_values

    def self.values
      @values ||= Array(valid_values).map { |val| new(val) }
    end

    def initialize(s)
      unless s.in?(Array(valid_values))
        raise ArgumentError, "#{s.inspect} is not a valid #{self.class} value"
      end

      super
    end

    def human_name
      if i18n_scope.blank?
        raise NotImplementedError, 'Your subclass must define :i18n_scope'
      end

      I18n.t!(value, scope: i18n_scope)
    end

    def value
      to_s
    end

    def as_json(opts = nil)
      {
        'value'      => value,
        'human_name' => human_name
      }
    end
  end
end

This base class handles everything we need: validating the values, converting to human readable names, and exporting to JSON. All we have to do is subclass it and set the two class attributes:

module Survey
  class Color < Enum
    self.i18n_scope = 'survey.colors'

    self.valid_values = %w(
      black
      brown
      gray
      orange
      yellow
      white
    )
  end

  class HairLength < Enum
    self.i18n_scope = 'survey.hair_lengths'

    self.valid_values = %w(
      less_than_1_inch
      1_to_3_inches
      longer_than_3_inches
    )
  end
end

Finally, we need to add our human readable translations to the locale file:

en:
  survey:
    colors:
      black: Black
      brown: Brown
      gray: Gray
      orange: Orange
      yellow: Yellow/Blonde
      white: White
    hair_lengths:
      less_than_1_inch: Less than 1 inch
      1_to_3_inches: 1 to 3 inches
      longer_than_3_inches: Longer than 3 inches

We now have an enumerated type in pure Ruby. The values look like strings while also having the custom behavior we need.

Survey::Color.values

# => ["black", "brown", "gray", "orange", "yellow", "white"]

Survey::Color.values.first.human_name

# => "Black"

Survey::Color.values.as_json

# => [{"value"=>"black", "human_name"=>"Black"}, {"value"=>"brown", "human_name"=>"Brown"}, ...]

The last step is to hook our new enumerated types into our AnswerKey model for great justice. We want color and hair_length to be automatically converted to instances of our new enum classes. Fortunately, my good friend Zachary has already solved that problem. We just have to update our Enum class with the right methods:

def self.load(value)
  if value.present?
    new(value)
  else
    # Don't try to convert nil or empty strings
    value
  end
end

def self.dump(obj)
  obj.to_s
end

And set up our model:

class AnswerKey < ActiveRecord::Base
  belongs_to :animal

  serialize :color,       Survey::Color
  serialize :hair_length, Survey::HairLength

  validates :color,       inclusion: { in: Survey::Color.values }
  validates :hair_length, inclusion: { in: Survey::HairLength.values }
end

BONUS TIP — We probably need to add these enums to a form in the admin interface, right? If you're using Formtastic, it automatically looks at our #human_name method and does the right thing:

f.input :color, as: :select, collection: Survey::Color.values

Shazam.

Hey friend, have you implemented enums in one of your Rails apps? How did you do that? Let me know in the comments below. Have a nice day.