tty-config 0.2.0 → 0.3.0

data/lib/tty/config.rb

@@ -30,6 +30,65 @@ module TTY
       end
     end
 
+    # Generate file content based on the data hash
+    #
+    # @param [Hash] data
+    #
+    # @return [String]
+    #   the file content
+    #
+    # @api public
+    def self.generate(data, separator: '=')
+      content  = []
+      values   = {}
+      sections = {}
+
+      data.keys.sort.each do |key|
+        val = data[key]
+        if val.is_a?(NilClass)
+          next
+        elsif val.is_a?(Hash) ||
+              (val.is_a?(Array) && val.first.is_a?(Hash))
+          sections[key] = val
+        elsif val.is_a?(Array)
+          values[key] = val.join(',')
+        else
+          values[key] = val
+        end
+      end
+
+      # values
+      values.each do |key, val|
+        content << "#{key} #{separator} #{val}"
+      end
+      content << '' unless values.empty?
+
+      # sections
+      sections.each do |section, object|
+        next if object.empty? # only add section if values present
+
+        content << "[#{section}]"
+        if object.is_a?(Array)
+          object = object.reduce({}, :merge!)
+        end
+        object.each do |key, val|
+          val = val.join(',') if val.is_a?(Array)
+          content << "#{key} #{separator} #{val}" if val
+        end
+        content << ''
+      end
+      content.join("\n")
+    end
+
+    # Storage for suppported format & extensions pairs
+    # @api public
+    EXTENSIONS = {
+      yaml: %w(.yaml .yml),
+      json: %w(.json),
+      toml: %w(.toml),
+      ini:  %w(.ini .cnf .conf .cfg .cf)
+    }.freeze
+
     # A collection of config paths
     # @api public
     attr_reader :location_paths
@@ -50,14 +109,25 @@ module TTY
     # @api public
     attr_reader :validators
 
-    def initialize(settings = {})
-      @location_paths = []
+    # The prefix used for searching ENV variables
+    # @api public
+    attr_accessor :env_prefix
+
+    # Create a configuration instance
+    #
+    # @api public
+    def initialize(**settings)
       @settings = settings
+      @location_paths = []
       @validators = {}
       @filename = 'config'
       @extname = '.yml'
-      @extensions = ['.yaml', '.yml', '.json', '.toml']
+      @extensions = EXTENSIONS.values.flatten << ''
       @key_delim = '.'
+      @envs = {}
+      @env_prefix = ''
+      @autoload_env = false
+      @aliases = {}
 
       yield(self) if block_given?
     end
@@ -88,6 +158,20 @@ module TTY
       @location_paths.unshift(path)
     end
 
+    # Check if env variables are auto loaded
+    #
+    # @api public
+    def autoload_env?
+      @autoload_env == true
+    end
+
+    # Auto load env variables
+    #
+    # @api public
+    def autoload_env
+      @autoload_env = true
+    end
+
     # Set a value for a composite key and overrides any existing keys.
     # Keys are case-insensitive
     #
@@ -123,6 +207,34 @@ module TTY
       block ? set(*keys, &block) : set(*keys, value: value)
     end
 
+    # Bind a key to ENV variable
+    #
+    # @example
+    #   set_from_env(:host)
+    #   set_from_env(:foo, :bar) { 'HOST' }
+    #
+    # @param [Array[String]] keys
+    #   the keys to bind to ENV variables
+    #
+    # @api public
+    def set_from_env(*keys, &block)
+      assert_keys_with_block(convert_to_keys(keys), block)
+      key = flatten_keys(keys)
+      env_key = block.nil? ? key : block.()
+      env_key = to_env_key(env_key)
+      @envs[key.to_s.downcase] = env_key
+    end
+
+    # Convert config key to standard ENV var name
+    #
+    # @param [String] key
+    #
+    # @api private
+    def to_env_key(key)
+      env_key = key.to_s.upcase
+      @env_prefix == '' ? env_key : "#{@env_prefix.to_s.upcase}_#{env_key}"
+    end
+
     # Fetch value under a composite key
     #
     # @param [Array[String|Symbol]] keys
@@ -131,9 +243,21 @@ module TTY
     #
     # @api public
     def fetch(*keys, default: nil, &block)
+      # check alias
+      real_key = @aliases[flatten_keys(keys)]
+      keys = real_key.split(key_delim) if real_key
+
       keys = convert_to_keys(keys)
+      env_key = autoload_env? ? to_env_key(keys[0]) : @envs[flatten_keys(keys)]
+      # first try settings
       value = deep_fetch(@settings, *keys)
+      # then try ENV var
+      if value.nil? && env_key
+        value = ENV[env_key]
+      end
+      # then try default
       value = block || default if value.nil?
+
       while callable_without_params?(value)
         value = value.call
       end
@@ -182,7 +306,38 @@ module TTY
       deep_delete(*keys, @settings)
     end
 
-    # Register validation for a nested key
+    # Define an alias to a nested key
+    #
+    # @example
+    #   alias_setting(:foo, to: :bar)
+    #
+    # @param [Array[String]] keys
+    #   the alias key
+    #
+    # @api public
+    def alias_setting(*keys, to: nil)
+      flat_setting = flatten_keys(keys)
+      alias_keys = Array(to)
+      alias_key = flatten_keys(alias_keys)
+
+      if alias_key == flat_setting
+        raise ArgumentError, 'Alias matches setting key'
+      end
+
+      if fetch(alias_key)
+        raise ArgumentError, 'Setting already exists with an alias ' \
+                             "'#{alias_keys.map(&:inspect).join(', ')}'"
+      end
+
+      @aliases[alias_key] = flat_setting
+    end
+
+    # Register a validation rule for a nested key
+    #
+    # @param [Array[String]] keys
+    #   a deep nested keys
+    # @param [Proc] validator
+    #   the logic to use to validate given nested key
     #
     # @api public
     def validate(*keys, &validator)
@@ -192,26 +347,8 @@ module TTY
       validators[key] = values
     end
 
-    # Check if key passes all registered validations
+    # Find configuration file matching filename and extension
     #
-    # @api private
-    def assert_valid(key, value)
-      validators[key].each do |validator|
-        validator.call(key, value)
-      end
-    end
-
-    # Delay key validation
-    #
-    # @api private
-    def delay_validation(key, callback)
-      -> do
-        val = callback.()
-        assert_valid(key, val)
-        val
-      end
-    end
-
     # @api private
     def find_file
       @location_paths.each do |location_path|
@@ -227,9 +364,10 @@ module TTY
     # @return [Boolean]
     #
     # @api public
-    def persisted?
+    def exist?
       !find_file.nil?
     end
+    alias persisted? exist?
 
     # Find and read a configuration file.
     #
@@ -239,17 +377,20 @@ module TTY
     # @param [String] file
     #   the path to the configuration file to be read
     #
+    # @param [String] format
+    #   the format to read configuration in
+    #
     # @raise [TTY::Config::ReadError]
     #
     # @api public
-    def read(file = find_file)
+    def read(file = find_file, format: :auto)
       if file.nil?
-        raise ReadError, "No file found to read configuration from!"
+        raise ReadError, 'No file found to read configuration from!'
       elsif !::File.exist?(file)
         raise ReadError, "Configuration file `#{file}` does not exist!"
       end
 
-      merge(unmarshal(file))
+      merge(unmarshal(file, format: format))
     end
 
     # Write current configuration to a file.
@@ -258,11 +399,11 @@ module TTY
     #   the path to a file
     #
     # @api public
-    def write(file = find_file, force: false)
+    def write(file = find_file, force: false, format: :auto)
       if file && ::File.exist?(file)
         if !force
           raise WriteError, "File `#{file}` already exists. " \
-                            "Use :force option to overwrite."
+                            'Use :force option to overwrite.'
         elsif !::File.writable?(file)
           raise WriteError, "Cannot write to #{file}."
         end
@@ -273,7 +414,8 @@ module TTY
         file = ::File.join(dir, "#{filename}#{@extname}")
       end
 
-      marshal(file, @settings)
+      content = marshal(file, @settings, format: format)
+      ::File.write(file, content)
     end
 
     # Current configuration
@@ -286,16 +428,57 @@ module TTY
 
     private
 
+    # Ensure that value is set either through parameter or block
+    #
+    # @api private
+    def assert_either_value_or_block(value, block)
+      if value.nil? && block.nil?
+        raise ArgumentError, 'Need to set either value or block'
+      elsif !(value.nil? || block.nil?)
+        raise ArgumentError, "Can't set both value and block"
+      end
+    end
+
+    # Check if object is a proc with no arguments
+    #
+    # @return [Boolean]
+    #
+    # @api private
     def callable_without_params?(object)
       object.respond_to?(:call) &&
         (!object.respond_to?(:arity) || object.arity.zero?)
     end
 
-    def assert_either_value_or_block(value, block)
-      if value.nil? && block.nil?
-        raise ArgumentError, "Need to set either value or block"
-      elsif !(value.nil? || block.nil?)
-        raise ArgumentError, "Can't set both value and block"
+    # Wrap callback in a proc object that includes validation
+    # that will be performed at point when a new proc is invoked.
+    #
+    # @param [String] key
+    # @param [Proc] callback
+    #
+    # @api private
+    def delay_validation(key, callback)
+      -> do
+        val = callback.()
+        assert_valid(key, val)
+        val
+      end
+    end
+
+    # Check if key passes all registered validations for a key
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @api private
+    def assert_valid(key, value)
+      validators[key].each do |validator|
+        validator.call(key, value)
+      end
+    end
+
+    def assert_keys_with_block(keys, block)
+      if keys.size > 1 && block.nil?
+        raise ArgumentError, 'Need to set env var in block'
       end
     end
 
@@ -407,61 +590,80 @@ module TTY
     end
 
     # @api private
-    def unmarshal(file)
-      ext = ::File.extname(file)
-      self.extname = ext
-      self.filename = ::File.basename(file, ext)
-      gem_name = nil
+    def unmarshal(file, format: :auto)
+      file_ext = ::File.extname(file)
+      ext = (format == :auto ? file_ext : ".#{format}")
+      self.extname  = file_ext
+      self.filename = ::File.basename(file, file_ext)
 
       case ext
-      when '.yaml', '.yml'
-        require 'yaml'
+      when *EXTENSIONS[:yaml]
+        load_read_dep('yaml', ext)
         if YAML.respond_to?(:safe_load)
           YAML.safe_load(File.read(file))
         else
           YAML.load(File.read(file))
         end
-      when '.json'
-        require 'json'
+      when *EXTENSIONS[:json]
+        load_read_dep('json', ext)
         JSON.parse(File.read(file))
-      when '.toml'
-        gem_name = 'toml'
-        require 'toml'
+      when *EXTENSIONS[:toml]
+        load_read_dep('toml', ext)
         TOML.load(::File.read(file))
+      when *EXTENSIONS[:ini]
+        load_read_dep('inifile', ext)
+        ini = IniFile.load(file).to_h
+        global = ini.delete('global')
+        ini.merge!(global)
       else
         raise ReadError, "Config file format `#{ext}` is not supported."
       end
+    end
+
+    # Try loading read dependency
+    # @api private
+    def load_read_dep(gem_name, format)
+      require gem_name
     rescue LoadError
-      puts "Please install `#{gem_name}`"
       raise ReadError, "Gem `#{gem_name}` is missing. Please install it " \
-                       "to read #{ext} configuration format."
+                       "to read #{format} configuration format."
     end
 
+    # Marshal data hash into a configuration file content
+    #
+    # @return [String]
+    #
     # @api private
-    def marshal(file, data)
-      ext = ::File.extname(file)
-      self.extname = ext
-      self.filename = ::File.basename(file, ext)
-      gem_name = nil
+    def marshal(file, data, format: :auto)
+      file_ext = ::File.extname(file)
+      ext = (format == :auto ? file_ext : ".#{format}")
+      self.extname  = file_ext
+      self.filename = ::File.basename(file, file_ext)
 
       case ext
-      when '.yaml', '.yml'
-        require 'yaml'
-        ::File.write(file, YAML.dump(self.class.normalize_hash(data, :to_s)))
-      when '.json'
-        require 'json'
-        ::File.write(file, JSON.pretty_generate(data))
-      when '.toml'
-        gem_name = 'toml'
-        require 'toml'
-        ::File.write(file, TOML::Generator.new(data).body)
+      when *EXTENSIONS[:yaml]
+        load_write_dep('yaml', ext)
+        YAML.dump(self.class.normalize_hash(data, :to_s))
+      when *EXTENSIONS[:json]
+        load_write_dep('json', ext)
+        JSON.pretty_generate(data)
+      when *EXTENSIONS[:toml]
+        load_write_dep('toml', ext)
+        TOML::Generator.new(data).body
+      when *EXTENSIONS[:ini]
+        Config.generate(data)
       else
         raise WriteError, "Config file format `#{ext}` is not supported."
       end
+    end
+
+    # Try loading write depedency
+    # @api private
+    def load_write_dep(gem_name, format)
+      require gem_name
     rescue LoadError
-      puts "Please install `#{gem_name}`"
-      raise ReadError, "Gem `#{gem_name}` is missing. Please install it " \
-                       "to read #{ext} configuration format."
+      raise WriteError, "Gem `#{gem_name}` is missing. Please install it " \
+                       "to read #{format} configuration format."
     end
   end # Config
 end # TTY