Really cool gems, like Carrierwave for example, have this neat feature of configuring the gem in runtime. It allows you to easily configure how the gem will behave in your app. For example, you can add various authentication keys, how errors should be handled and what not. If you want to add this cool functionality in your gems, read on to find out more.
Personally, I love to implement (and use) this way of configuring libraries in runtime. Although people have used and blogged about this “pattern” so many times, I am writing another how-to because I really like this type of configuring external libs/gems. So, if you’ve ever wondered how to implement it, here is another how-to.
Lets build a gem that generates random numbers. We’ll call it Randomizer. Basically, every gem is a module, that namespaces bunch of classes and methods. So, say we want our gem to have one method, called generate! that will return our random number. Under the hood, we’ll just use the built in rand method.
module Randomizer class << self def generate! rand end end end
This is all good, the rand method will generate a really long Float. But, lets say that we want the generate! method to return a number up to a maximum number? We can change the method to accept a number as an argument and pass that number as an argument to the rand method.
module Randomizer class << self def generate! max rand max end end end
Again, really simple. But, what if we want to set a range for the random number that will be generated? For example, for whatever reason an user might want the method to return random numbers between 50 and 60. How can we do this?
Well, one approach is to make the generate! method accept two arguments, which is fine. But, instead of passing the arguments every time we make the call, we can add a configuration block so the gem always returns random numbers in a range. This is where we need to introduce the configure block.
module Randomizer class << self attr_accessor :configuration def configure @config ||= Configuration.new yield(@config) end end class Configuration attr_accessor :from, :to end end
How does this work? The configure class method stores a Configuration object inside the Randomizer module. Anything set from the configure block is an attr_accessor on the Configuration class. Now, lets add the generate! method back in and see how we can use the configure block.
module Randomizer class << self attr_accessor :configuration def configure @configuration ||= Configuration.new yield(@configuration) end def generate! (configuration.from..configuration.to).to_a.sample end end class Configuration attr_accessor :from, :to end end
Now, the generate! method takes the from and to attributes from the configuration object and creates an array of it. Then, we use the Array#sample method which picks a random item from an array object. So, say you have a Rails app where you want to use the Randomizer gem. Configuring the gem can be done by adding a randomizer.rb file in the config/initializers folder. Then, we need to use the configure block in the file.
Randomizer.configure do |config| config.from = 100 config.to = 200 end
Now, when we call Randomizer.generate! the method will return a random number between 100 and 200. Hope my explanation was good and you understood how you can use this “pattern”.
What do you think, how we can adjust the gem so the method returns an array of two random numbers? And how we can adjust the gem so the method will return a custom number of random numbers in an array?
Feel free to share your solution in the comments. Thanks for reading!
Liked this article? Subscribe to my newsletter and get future articles in your inbox. It's a short and sweet read, going out to +1000 of other engineers.
I care about your privacy, and will never send you spam. You can unsubscribe at any time.