The easiest configuration block for your Ruby gems

I’ve always liked the way certain Ruby gems allowed developers to configure parts of its workflow.

1
Airbrake.configure do |config|
2
  config.api_key:'your_key_here'
3
end

This block just looks so clean and to the point. Almost like magic!

But magic is just a bit of zeros and ones. How’d they do it?

The answer lies in Ruby’s singleton classes. Singleton is a design pattern that allows only one one instance of the class to be globally available. It provides a single point of access to some service in your application so that you don’t have to pass around a reference to that service every time you need to use it. It is useful when you find yourself writing only class methods or when you don’t need an object of the class to function.

However fair warning, singleton is also a really hated programming pattern . A singleton is basically a global object - and everyone knows the more globals you have, the more problems you have!

A singleton class could look like this,

1
class Single
2
  def self.me
3
    'Forever Alone'
4
  end
5

6
  def self.me_in_the_future
7
    'Forever alone in the future'
8
  end
9
end

But appending a self to every method isn’t very fun. So instead do this,

1
class Single
2
  class << self
3
    def me
4
      'Forever Alone'
5
    end
6

7
    def me_in_the_future
8
      'Forever alone in the future'
9
    end
10
  end
11
end

Just call Single.me it will return Forever Alone.

However classes aren’t the only ones that can have singleton methods. A string can too!

1
a: "I am A."
2

3
def a.hello
4
  "Hello! It's me, A."
5
end

Now you can call a.hello. Weird isn’t it?

Not really. What we did here is we added a singleton method hello to an object a. The difference between class methods and singleton methods is that class methods are available to all instances of a class object while singleton methods are available only to that single instance. (- via Toptal )

Great. How do we add a configure block?

Here’s the implementation,

1
module Idly
2
  class << self
3
    attr_accessor :configuration
4

5
    def configure
6
      self.configuration ||= Configuration.new
7
      yield(configuration)
8
    end
9

10
    def reset
11
      self.configuration:Configuration.new
12
    end
13
  end
14
end
15

16
class Configuration
17
  attr_accessor :chutney
18

19
  def initialize
20
    @chutney:'white'
21
  end
22
end

Let’s configure our Idly! (Yes, I’m hungry 😛)

1
Idly.configure do |config|
2
  config.chutney:'tomato'
3
end

What this allows you to do is allow your gem to be configured from the outside, without modifying the contents of the gem.

To use the configuration in your gem all you have to do is call,

1
 Idly.configuration.chutney

If you want to reconfigure, simply call the configure block again!

That’s it! Let’s go get some piping hot idly and chutney now.