Chain of Responsibility Pattern in Ruby on Rails

While we were working on a project we stumbled upon some legacy code that consists of huge ‘if else’ statements. In this post we’ll show you how we refactored it using the Chain of responsibility pattern.

What is the definition of the Chain of responsibility pattern?

Chain the receiving objects and pass the request along the chain until an object handles it.

– Krzysztof Kempinski, Chain of Responsibility Design Pattern in Ruby

It may be useful if we need to store some data that is not related to any model. Essentially, it’s an object oriented version of if … elsif … elsif … else … end that is much much easier to extend. Because of that we can’t use hashes. Processing objects, aka handlers, contain logic for handling exactly one case.

So where can we use it? For example we could define a chain for handling payments. One handler would take care of payment for one provider such as payU, credit card, bank transfer.

So why did we use it?

We were working with big and messy legacy code. There was a gigant if else statement in one of the services. In our case it was responsible for choosing shipping provider based on selected carrier and shipment. It was taking into account saved api keys for providers, which provider was enabled in the given store and some other stuff. There were a lot of different cases, every case was handled differently, each one of them consisted of about 50-line method.

Another reason

Services are usually used for everything in Rails, which may not always be an ideal solution. This is our old, but good post about basic design patterns. Services may be very helpful when we have a lot of processes to accomplish, but in our opinion they are overused. Also services should be responsible for only one thing, as deciding how to handle something and handling it are two completely different things

Our Idea?

Check which provider supports chosen carrier, then make sure that selected carrier is active for current provider. If not, continue checking.

Implementation

We have created main Chain object, which initializes all handlers and creates a “chain”.

1class BasicChain
2 class << self
3   def resolve(*args)
4     mapped_handlers[0...-1].each_with_index do |handler, index|
5       mapped_handlers[index + 1].successor = handler
6     end
7     mapped_handlers.last.call(*args)
8   end
9
10   def handlers
11     []
12   end
13
14   def mapped_handlers
15     @mapped_handlers ||= handlers.map(&:new)
16   end
17 end
18end

It’s an interface for all future chains, it initializes handlers and assigns successor to each one of them. As you can see in the code below, successor is just a next handler in the chain.

We’ve also implemented BaseHandler

1class BaseHandler
2  attr_accessor :successor
3
4  def initialize(successor = nil)
5    @successor = successor
6  end
7
8  def call
9    raise "#call method should be implemented"
10  end
11end

BaseHandler is an interface for all future handlers. In initializer, we provide a successor, which defines a next handler of the Chain, which will be executed if condition for the current handler is false (in this case, the carrier name is not passing).

BasicChain and BaseHandler provides pattern how every other Chain should look like. So, while creating a new chain, we need an array of handlers as it defines an order in chain and what handlers are involved in the chain.

1module ShippingProviderChain
2  class Chain < BasicChain
3    class << self
4      def handlers
5        [
6          ShippingProviderChain::DefaultProviderHandler,
7          ShippingProviderChain::SecondProviderHandler,
8          ShippingProviderChain::FirstProviderHandler
9        ]
10      end
11    end
12  end
13end

As you can see in the example below, handler returns active provider when a certain condition is met. In any other case it passes all received data to the next handler in the chain.

1module ShippingProviderChain
2  class BaseShippingHandler < BaseHandler
3    UNKNOWN_PROVIDER = "unknown".freeze
4    PROVIDER = "".freeze
5    SUPPORTED_CARRIERS = [].freeze
6
7    def call(carrier_name, shop)
8      return active_provider(carrier_name, shop) if supported_carrier?(carrier_name)
9      return successor.call(carrier_name, shop) if successor.present?
10      UNKNOWN_PROVIDER
11    end
12
13    def active_provider(carrier_name)
14      PROVIDER
15    end
16
17    private
18
19    def supported_carrier?(carrier_name)
20      carrier_name.in?(CARRIERS)
21    end
22  end
23end

Here’s an example of an implementation of a handler which selects FirstProvider if direct integration with this provider is enabled. If not, it selects unifaun if indirect integration enabled.

1module ShippingProviderChain
2  class FirstProviderHandler < BaseShippingHandler
3    PROVIDER = "first_provider".freeze
4    CARRIERS = ["gls", "dhl", "..."]
5
6    def active_provider(carrier_name, shop)
7      if shop.first_provider.direct_integration_enabled?
8        # select first provider
9      elsif shop.unifaun_provider.enabled?
10        # select unifaun
11      else
12        BaseShippingHandler::UNKNOWN_PROVIDER
13      end
14    end
15
16    private
17
18    def supported_carrier?(carrier_name)
19      carrier_name.in?(CARRIERS)
20    end
21  end
22end