Ruby on Rails: Active Record Enum

Gregory Bryant
Feb 7 · 5 min read
Design by Joy Park

Writing software from scratch can be a satisfying journey full of planning, implementing, and revising. While in the development phase, decisions can be temporary and easily undone, allowing development to take new paths.

Coming into an existing live codebase is an entirely different task since decisions have already been made, and they are not easily changed. A good starting point is to make a small, low-risk change that can have good returns.

A recent project I worked on included an order model and order status model, both backed by database tables and developed using Ruby on Rails. The code utilizing the models involved magic numbers as a means of checking and setting statuses.

For example:

order.status = 2

or

if order.status == 3 then
<insert complex operations here>
end

The numbers could be swapped out with constants, but ActiveRecord has built-in functionality for enums. The ActiveRecord implementation of enums seems intended for models with an integer field for the enumerated value, a situation that does not match my project.

Here is the assumption for implementing ActiveRecord enums:

class CreateOrders < ActiveRecord::Migration[5.2]
def change
create_table :orders do |t|
t.date :created_at
t.decimal :total
t.integer :order_status
t.timestamps
end
end
end

Where my existing project is structured as:

class CreateOrderStatuses < ActiveRecord::Migration[5.2]
def change
create_table :order_statuses do |t|
t.string :order_status
t.timestamps
end
end
end
class CreateOrders < ActiveRecord::Migration[5.2]
def change
create_table :orders do |t|
t.date :created_at
t.decimal :total
t.belongs_to :order_status, foreign_key: true
t.timestamps
end
end
end

Through some trial and error, I was able to implement a solution that makes use of the built-in functionality that ActiveRecord enums provide while not having to make any changes to my database schema or breaking changes to my existing production codebase.

To follow along with me you can use the following instructions.

Navigate to the folder that will hold your project files.

cd ~/Projects/Rails/

Create the file seeds.rb

~/Projects/Rails/seeds.rb

and paste in the following:

OrderStatus.create(order_status:'open')
OrderStatus.create(order_status:'hold')
OrderStatus.create(order_status:'closed')
(1..100).each {|i| Order.create(total:rand(10000),created_at:rand(Time.now-2.years..Time.now),order_status_id:rand(1..3))}

Then, execute the following:

rails new enum
cd enum
spring stop
cp ../seeds.rb db/seeds.rb
rails generate model OrderStatus order_status
rails generate model Order created_at:datetime total:decimal order_status:references
rake db:migrate
rake db:seed

Excellent! Now we can get to work. Let’s begin by firing up a rails console (rails c) and see what we are starting with.

To test if the first order in our database is closed here is what some of the current options look like:

Order.first.order_status==OrderStatus.where(order_status:"open").first

Order.first.order_status==1

The first way is not convenient and is error-prone and the second is what we are trying to avoid. To improve the situation, we will add some enum notation to our models.

Modify the following files accordingly:

order_status.rb:

class OrderStatus < ApplicationRecord
enum status: {'open':1,'hold':2,'closed':3}
end

order.rb:

class Order < ApplicationRecord
has_one :order_status
enum order_status_id: OrderStatus.statuses
end

We have now gained the following functionality:

> o = Order.first
> o.open?
=> false
o.order_status_id=1
> o.open?
=> true
o.close!
> o.open?
=> false
Order.open
=> <list of open orders>

but also some problems:

> o = Order.first
> o.hold!
> o.hold?
=> true
> o.order_status_id==OrderStatus.where(order_status:'hold').first.id
=> false
> o.order_status_id
=> "hold"
> Order.where(order_status:'open')
=> #<ActiveRecord::Relation []>

If we want to add this functionality to the order_status field, it will require some more work.

Create the file order_status_enum.rb in the model directory and paste in the following code:

module OrderStatusEnum

def order_status
self.method(:order_status_id).super_method.call.to_s
end

def order_status=(value)
if value.is_a? String
self.method(:order_status_id=).super_method.call(value)
elsif value.is_a? Symbol
self.method(:order_status_id=).super_method.call(value.to_s)
else
raise ArgumentError.new "#{value} is not a valid order_status"
end
end

def order_status_id
OrderStatus.statuses[self.method(:order_status_id).super_method.call]
end

def order_status_id=(value)
if value.is_a? Integer
self.method(:order_status_id=).super_method.call(value)
else
raise ArgumentError.new "#{value} is not a valid order_status_id"
end
end

end

To include this new module in your model, make the following change to order.rb:

class Order < ApplicationRecord
has_one :order_status
prepend OrderStatusEnum
enum order_status_id: OrderStatus.statuses
end

This change forces order_status and order_status_id to behave as expected. Trying to use the Active Record query interface will still produce an error, to fix this we need to make an alias linking order_status to order_status_id. Make the following change to order.rb:

class Order < ApplicationRecord
has_one :order_status
prepend OrderStatusEnum
enum order_status_id: OrderStatus.statuses
alias_attribute :order_status, :order_status_id
end

Now everything is working as expected, but we are still comparing status against hardcoded strings, which can be fixed by making the following change.

order_status.rb:

class OrderStatus < ApplicationRecord 
enum status: {'open':1,'hold':2,'closed':3}
OPEN='open'
HOLD='hold'
CLOSED='closed'
end

This allows us to test for status as follows:

> o.order_status == OrderStatus::OPEN
=> true

All is looking well, except I have neglected to mention the harmless informational messages:

Creating scope :open. Overwriting existing method OrderStatus.open.Creating scope :open. Overwriting existing method Order.open.

All Ruby objects inherit from Object, which includes the Kernel module, which in turn, has an open method. In my situation, I do not use the Kernel module’s open method and I need to keep the naming consistent with the existing project. To silence these messages we can make the following change to order_status.rb:

class OrderStatus < ApplicationRecord 
class << self
undef open
end
enum status: {'open':1,'hold':2,'closed':3}
OPEN='open'
HOLD='hold'
CLOSED='closed'
end

By adding enumerations to the project, we have added clarity by making comparisons using descriptive language instead of numbers, and we have the safety of only the defined order states being valid for assignment and comparison. We have also added convenience through the extra query and assignment methods that Active Record provides with enum types.

As a software engineer, I have to weigh early decisions against their effect in the near and long term. Saving an hour today can cost a project countless hours in the future to undo or accommodate that decision. Besides raw engineering hours, there is also the learning curve for new team members coming into a codebase. Having code be self-documenting by using the functionality within your stack will also help future engineers coming onto the project.


As ever, QuarkWorks is available to help with any software application project — web, mobile, and more! If you are interested in our services you can check out our website. We would love to answer any questions you have! Just reach out to us on our Twitter, Facebook, or LinkedIn.

QuarkWorks, Inc.

Build better software.

Welcome to a place where words matter. On Medium, smart voices and original ideas take center stage - with no ads in sight. Watch
Follow all the topics you care about, and we’ll deliver the best stories for you to your homepage and inbox. Explore
Get unlimited access to the best stories on Medium — and support writers while you’re at it. Just $5/month. Upgrade