Try to solve this real problem: Configuration Management

• Multiple Instances: If the configuration settings are loaded in multiple places, it can lead to inconsistencies and increased memory usage.
• Global Access: You need a way to access these settings globally without passing them around as parameters.

Singleton Pattern

• Single Instance: Only one instance of the class is created.
• Global Access Point: Provides a way to access the instance globally.
• Lazy Initialization: The instance is created only when it is needed.

Implementing Singleton in Ruby

// language: ruby
class ConfigurationManager  
  @instance = nil  
  private_class_method :new # Prevent user from using ConfigurationManager.new  

  def self.instance    
    @instance ||= new # Only call new when instance is nil  
  end  
  
  def initialize    
    @settings = {}  
  end  
  
  def load_settings(file)    
    # Simulate loading settings from a file    
    @settings = { db: 'localhost', api_key: '12345' }    
    puts "Settings loaded from #{file}"  
  end  

  def get_setting(key)    
    @settings[key]  
  end
end

// language: ruby
require 'singleton'

class ConfigurationManager  
  include Singleton  

  def initialize    
    @settings = {}  
  end  

  def load_settings(file)    
    @settings = { db: 'localhost', api_key: '12345' }    
    puts "Settings loaded from #{file}"  
  end  

  def get_setting(key)    
    @settings[key]  
  end
end

// language: ruby
config_manager = ConfigurationManager.instance
config_manager.load_settings('config.yml')

another_config_manager = ConfigurationManager.instance
puts another_config_manager.get_setting(:db)  # Output: localhost

# Both instances are the sameputs 
config_manager.equal?(another_config_manager)  # Output: true

More Practical Examples

// language: ruby
require 'singleton'
class Logger
  include Singleton
  def initialize
    @log_file = File.open('application.log', 'a')
  end

  def log(message)
    @log_file.puts(message)
    @log_file.flush
  end
end

# Usage
logger = Logger.instance
logger.log('This is a log message.')

// language: ruby
require 'singleton'
class CacheManager
  include Singleton
  def initialize
    @cache = {}
  end

  def store(key, value)
    @cache[key] = value
  end

  def fetch(key)
    @cache[key]
  end
end

# Usage
cache = CacheManager.instancecache.store('user_1', { name: 'John Doe', age: 30 })
another_cache = CacheManager.instance
puts another_cache.fetch('user_1')  # Output: {:name=>"John Doe", :age=>30}

// language: ruby
require 'singleton'
class AppSettings
  include Singleton

  def initialize
    @settings = { theme: 'dark', language: 'en' }
  end

  def get_setting(key)
    @settings[key]
  end

  def set_setting(key, value)
    @settings[key] = value
  end
end

# Usage
settings = AppSettings.instance
puts settings.get_setting(:theme)  # Output: dark

settings.set_setting(:theme, 'light')
puts settings.get_setting(:theme)  # Output: light

Multi-Thread/Process Applications

// language: ruby
require 'singleton'
require 'thread'

class ThreadSafeSingleton
  @instance = nil
  @mutex = Mutex.new

  private_class_method :new

  def self.instance
    return @instance if @instance

    @mutex.synchronize do
      @instance ||= new
    end

    @instance
  end

  def initialize
    # initialization code
  end
end

# Usage in a multi-threaded environment
threads = 10.times.map do
  Thread.new do
    singleton = ThreadSafeSingleton.instance
    puts singleton.object_id
  end
end
threads.each(&:join)

Conclusion