require 'dotenv' # Hot Live Constants module Hot::Constants HOTENV = {} # rubocop:disable Style/MutableConstant LISTENERS = {} # rubocop:disable Style/MutableConstant LOGGER = SemanticLogger[self] TOTO = 'titi' class << self def initialize @old_definitions = {} @hot_definitions = {} load_definitions load_values end def load_definitions LOGGER.debug('--load_definitions3') new_definitions = Dotenv.parse('.env.sample') definitions_to_actualize = {} @old_definitions.merge(new_definitions) do |key, old_value, new_value| definitions_to_actualize[key] = new_value if new_value != old_value end definitions_to_actualize.each { |key, value| define_method(:actualize, key, value) } @old_definitions = new_definitions definitions_to_remove = @hot_definitions.except(*new_definitions.keys) definitions_to_remove.each_pair do |key, dkey| LOGGER.info("remove method <#{dkey}>") singleton_class.undef_method(dkey) @hot_definitions.delete(key) end definitions_to_add = new_definitions.except(*@hot_definitions.keys) definitions_to_add.each { |key, value| define_method(:add, key, value) } end def load_values LOGGER.debug('--load_values') new_env = Dotenv.parse constants_to_delete = HOTENV.except(*new_env.keys) constants_to_delete.each do |name, _| # FIXME: default should read default and type from @old_definitions type, default = @old_definitions[name] LOGGER.info("constant <#{name}> reverts to default value <#{default}> of type <#{type}>") end constants_to_add = new_env.except(*HOTENV.keys) constants_to_add.each do |constant| LOGGER.info("constant to add <#{constant}>") end HOTENV.replace new_env # LISTENERS.each_pair { |k, b| perform_change(k, b) } end def on_change(key, &block) LISTENERS[key.downcase.to_sym] = block perform_change(key, block) end private def define_method(mode, key, value) dkey = key.downcase method = infer_method_from_value(value) inferred_type = method.name.to_s.split('_')[1] LOGGER.info("#{mode} method <#{dkey}> of type <#{inferred_type}> with default value <#{value}> ") singleton_class.define_method(dkey) { method.call(key, value) } @hot_definitions.store(key, dkey) end def perform_change(key, block) old_value = nil # TODO: remember last previous value new_value = method(key).call block.call(new_value, old_value) end def load_boolean(key, default) = HOTENV.fetch(key, default).to_s.downcase == 'true' def load_integer(key, default) = HOTENV.fetch(key, default).to_i def load_string(key, default) = HOTENV.fetch(key, default) def infer_method_from_value(value) case value.downcase when /^(true|false)$/ then method(:load_boolean) when /^\d+$/ then method(:load_integer) else method(:load_string) end end end initialize # done once on first require, cause this is just a module (not a class!) end