What is the correct way to write a singleton pattern in Ruby?

Question

I'm trying to write the most secure singleton in Ruby that I can. I'm new to the language, which is so elastic that I don't have a strong feeling that my singleton class will be successful at creating only one instance. As a bonus, I'd like the object to only become instantiated if really used.

Solution 1

# require singleton lib
require 'singleton'
class AppConfig
  # mixin the singleton module
  include Singleton
  # do the actual app configuration
  def load_config(file)
    # do your work here
    puts "Application configuration file was loaded from file: #{file}"
  end
end

conf1 = AppConfig.instance
conf1.load_config "/home/khelll/conf.yml"
#=>Application configuration file was loaded from file: /home/khelll/conf.yml
conf2 = AppConfig.instance
puts conf1 == conf2
#=>true
# notice the following 2 lines won’t work
AppConfig.new rescue(puts $!)
#=> new method is private
# dup won’t work
conf1.dup rescue(puts $!)
#=>private method `new’ called for AppConfig:Class
#=>can’t dup instance of singleton AppConfig

So what does ruby do when you include the singleton module inside your class?

1. It makes the new method private and so you can’t use it.
2. It adds a class method called instance that instantiates only one instance of the class.

So to use ruby singleton module you need two things:

1. Require the lib singleton then include it inside the desired class.
2. Use the instance method to get the instance you need.

Solution 2

If you want to create a singleton, why bother creating a class? Just create an object, and add the methods and instance variables to it you want.

>> MySingleton = Object.new
=> #<Object:0x100390318>
>> MySingleton.instance_eval do
?>   @count = 0
>>   def next
>>     @count += 1
>>   end
>> end
=> nil
>> MySingleton.next
=> 1
>> MySingleton.next
=> 2
>> MySingleton.next
=> 3

A more standard way that people implement this pattern is to use a Module as the singleton object (rather than the more generic Object):

>> module OtherSingleton
>>   @index = -1
>>   @colors = %w{ red green blue }
>>   def self.change
>>     @colors[(@index += 1) % @colors.size]
>>   end
>> end
=> nil
>> OtherSingleton.change
=> "red"
>> OtherSingleton.change
=> "green"
>> OtherSingleton.change
=> "blue"
>> OtherSingleton.change
=> "red"

If you wanted your singleton object to inherit from some class, just make it an instance of that class. To inherit from a mixin, just use #extend. If you want a singleton object, ruby makes it really easy, and unlike other languages, it doesn't have to be defined in a class.

Ad-hoc singletons (my first example) are all over the place, and cover the majority of cases I've encountered. The module trick normally covers the rest (when I want something a little more formal).

Ruby code should (imho) use duck typing (via #respond_to?) rather than explicitly checking an object's class, so I normally don't care about the uniqueness of my singleton objects' class, since it's not its class that makes it unique, but everything I added after.

Solution 3

require 'singleton'
class Klass
    include Singleton
    # ...
end

See the Ruby Standard Library Singleton class documention for an explanation.

Comments

[Chris McCauley]

+1 for pointing out that singleton isn't really needed. You can implement the intention without slavishly copying the pattern.

[gtd]

I've been thinking hard about this point since it brings into question the very existence of the Singleton module in ruby core. The potential utility of the class w/ Singleton mixin strike me as twofold: 1) if you want both class and instance methods and 2) if you have complicated initialization that you want to run lazily without requiring the module methods to all somehow trigger it explicitly the first time they're accessed. Does anyone else have any advantages of the actual Singleton module?