configurate 0.1.0 → 0.5.0

data/lib/configurate/provider/dynamic.rb

@@ -1,23 +1,40 @@
-module Configurate; module Provider
-  # This provider knows nothing upon initialization, however if you access
-  # a setting ending with +=+ and give one argument to that call it remembers
-  # that setting, stripping the +=+ and will return it on the next call
-  # without +=+.
-  class Dynamic < Base
-    def initialize
-      @settings = {}
-    end
+# frozen_string_literal: true
+
+module Configurate
+  module Provider
+    # This provider knows nothing upon initialization, however if you access
+    # a setting ending with +=+ and give one argument to that call it remembers
+    # that setting, stripping the +=+ and will return it on the next call
+    # without +=+. Sending +reset_dynamic!+ to it will make it forget all
+    # settings. Also assigning nil will have the effect of it forgetting
+    # a setting.
+    class Dynamic < Base
+      def lookup_path(setting_path, *args)
+        if setting_path.to_s == "reset_dynamic!"
+          @settings = nil
+          return true
+        end
+
+        if setting_path.setter? && !args.empty?
+          *root, key = setting_path.to_a
+          hash = root.inject(settings) {|hash, key| hash[key] }
+          hash[key] = extract_value(args)
+        end
+
+        Provider.lookup_in_hash setting_path, settings
+      end
 
-    def lookup_path(setting_path, *args)
-      if setting_path.is_setter? && args.length > 0
+      private
+
+      def settings
+        @settings ||= Hash.new {|hash, key| hash[key] = Hash.new(&hash.default_proc) }
+      end
+
+      def extract_value args
         value = args.first
         value = value.get if value.respond_to?(:_proxy?) && value._proxy?
-        *root, key = setting_path.to_a
-        hash = root.inject(@settings) {|hash, key| hash[key] ||= {} }
-        hash[key] = value
+        value
       end
-
-      Provider.lookup_in_hash setting_path, @settings
     end
   end
-end; end
+end

data/lib/configurate/provider/env.rb

@@ -1,17 +1,21 @@
-module Configurate; module Provider
-  # This provider looks for settings in the environment.
-  # For the setting +foo.bar_baz+ this provider will look for an
-  # environment variable +FOO_BAR_BAZ+, joining all components of the 
-  # setting with underscores and upcasing the result.
-  # If an value contains any commas (,) it's split at them and returned as array.
-  class Env < Base
-    def lookup_path(setting_path, *args)
-      value = ENV[setting_path.join("_").upcase]
-      unless value.nil?
-        value = value.dup
-        value = value.split(",") if value.include?(",")
+# frozen_string_literal: true
+
+module Configurate
+  module Provider
+    # This provider looks for settings in the environment.
+    # For the setting +foo.bar_baz+ this provider will look for an
+    # environment variable +FOO_BAR_BAZ+, joining all components of the
+    # setting with underscores and upcasing the result.
+    # If an value contains any commas (,) it's split at them and returned as array.
+    class Env < Base
+      def lookup_path(setting_path, *_args)
+        value = ENV[setting_path.join("_").upcase]
+        unless value.nil?
+          value = value.dup
+          value = value.split(",") if value.include?(",")
+        end
+        value
       end
-      value
     end
   end
-end; end
+end

data/lib/configurate/provider/string_hash.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Configurate
+  module Provider
+    # This provider takes a nested string keyed hash and does nested lookups in it.
+    class StringHash < Base
+      # @param hash [::Hash] the string keyed hash to provide values from
+      # @param namespace [String] optionally set this as the root
+      # @param required [Boolean] whether or not to raise an error if
+      #   the namespace, if given, is not found. Defaults to +true+.
+      # @param raise_on_missing [Boolean]  whether to raise {Configurate::MissingSetting}
+      #   if a setting can't be provided. Defaults to +false+.
+      # @param source [String] optional hint of what's the source of this configuration. Used in error messages.
+      # @raise [ArgumentError] if the namespace isn't found in the hash or the given object is not a hash
+      def initialize hash, namespace: nil, required: true, raise_on_missing: false, source: nil
+        raise ArgumentError, "Please provide a hash" unless hash.is_a?(Hash)
+
+        @required = required
+        @raise_on_missing = raise_on_missing
+        @source = source
+        @settings = root_from hash, namespace
+      end
+
+      def lookup_path setting_path, *_
+        Provider.lookup_in_hash(setting_path, @settings) {
+          raise MissingSetting.new "#{setting_path} is not a valid setting." if @raise_on_missing
+
+          nil
+        }
+      end
+
+      private
+
+      def root_from hash, namespace
+        return hash if namespace.nil?
+
+        Provider.lookup_in_hash(SettingPath.new(namespace), hash) do
+          raise ArgumentError, "Namespace #{namespace} not found #{"in #{@source}" if @source}" if @required
+
+          warn "WARNING: Namespace #{namespace} not found #{"in #{@source}" if @source}"
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/configurate/provider/toml.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "configurate"
+
+module Configurate
+  module Provider
+    # This provider tries to open a TOML file and does nested lookups
+    # in it.
+    class TOML < StringHash
+      begin
+        require "toml-rb"
+        PARSER = TomlRB
+      rescue LoadError => e
+        require "tomlrb"
+        PARSER = Tomlrb
+      end
+
+      # @param file [String] the path to the file
+      # @param namespace [String] optionally set this as the root
+      # @param required [Boolean] whether or not to raise an error if
+      #   the file or the namespace, if given, is not found. Defaults to +true+.
+      # @param raise_on_missing [Boolean]  whether to raise {Configurate::MissingSetting}
+      #   if a setting can't be provided. Defaults to +false+.
+      # @raise [ArgumentError] if the namespace isn't found in the file
+      # @raise [Errno:ENOENT] if the file isn't found
+      def initialize file, namespace: nil, required: true, raise_on_missing: false
+        super(PARSER.load_file(file),
+          namespace:        namespace,
+          required:         required,
+          raise_on_missing: raise_on_missing,
+          source:           file
+        )
+      rescue Errno::ENOENT => e
+        warn "WARNING: Configuration file #{file} not found, ensure it's present"
+        raise e if required
+      end
+    end
+  end
+end

data/lib/configurate/provider/yaml.rb

@@ -1,37 +1,31 @@
-require 'yaml'
+# frozen_string_literal: true
 
-module Configurate; module Provider
-  # This provider tries to open a YAML file and does nested lookups
-  # in it.
-  class YAML < Base
-    # @param file [String] the path to the file
-    # @param opts [Hash]
-    # @option opts [String] :namespace optionally set this as the root
-    # @option opts [Boolean] :required wheter or not to raise an error if
-    #   the file or the namespace, if given, is not found. Defaults to +true+.
-    # @raise [ArgumentError] if the namespace isn't found in the file
-    # @raise [Errno:ENOENT] if the file isn't found
-    def initialize file, opts = {}
-      @settings = {}
-      required = opts.delete(:required) { true }
+require "yaml"
 
-      @settings = ::YAML.load_file(file)
-
-      namespace = opts.delete(:namespace)
-      unless namespace.nil?
-        @settings = Provider.lookup_in_hash(SettingPath.new(namespace), @settings) do
-          raise ArgumentError, "Namespace #{namespace} not found in #{file}" if required
-          $stderr.puts "WARNING: Namespace #{namespace} not found in #{file}"
-          nil
-        end
+module Configurate
+  module Provider
+    # This provider tries to open a YAML file and does nested lookups
+    # in it.
+    class YAML < StringHash
+      # @param file [String] the path to the file
+      # @param namespace [String] optionally set this as the root
+      # @param required [Boolean] whether or not to raise an error if
+      #   the file or the namespace, if given, is not found. Defaults to +true+.
+      # @param raise_on_missing [Boolean]  whether to raise {Configurate::MissingSetting}
+      #   if a setting can't be provided. Defaults to +false+.
+      # @raise [ArgumentError] if the namespace isn't found in the file
+      # @raise [Errno:ENOENT] if the file isn't found
+      def initialize file, namespace: nil, required: true, raise_on_missing: false
+        super(::YAML.load_file(file),
+          namespace:        namespace,
+          required:         required,
+          raise_on_missing: raise_on_missing,
+          source:           file
+        )
+      rescue Errno::ENOENT => e
+        warn "WARNING: Configuration file #{file} not found, ensure it's present"
+        raise e if required
       end
-    rescue Errno::ENOENT => e
-      $stderr.puts "WARNING: Configuration file #{file} not found, ensure it's present"
-      raise e if required
-    end
-
-    def lookup_path setting_path, *_
-      Provider.lookup_in_hash(setting_path, @settings)
     end
   end
-end; end
+end

data/lib/configurate/proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Configurate
   # Proxy object to support nested settings
   #
@@ -18,40 +20,66 @@ module Configurate
       @lookup_chain = lookup_chain
       @setting_path = SettingPath.new
     end
-    
+
     def !
       !target
     end
-    
-    [:!=, :==, :eql?].each do |method|
+
+    %i[!= == eql? coerce].each do |method|
       define_method method do |other|
         target.public_send method, target_or_object(other)
       end
     end
-    
+
+    {
+      to_int:  :to_i,
+      to_hash: :to_h,
+      to_str:  :to_s,
+      to_ary:  :to_a
+    }.each do |method, converter|
+      define_method method do
+        value = target
+        return value.public_send converter if value.respond_to? converter
+
+        value.public_send method
+      end
+    end
+
     def _proxy?
       true
     end
-    
+
     def respond_to? method, include_private=false
       method == :_proxy? || target_respond_to?(method, include_private)
     end
-    
+
     def send *args, &block
       __send__(*args, &block)
     end
     alias_method :public_send, :send
-    
+
+    def singleton_class
+      target.singleton_class
+    rescue ::TypeError
+      class << self
+        self
+      end
+    end
+
+    # rubocop:disable Style/MethodMissingSuper we handle all calls
+    # rubocop:disable Style/MissingRespondToMissing we override respond_to? instead
+
     def method_missing setting, *args, &block
       return target.public_send(setting, *args, &block) if target_respond_to? setting
 
       @setting_path << setting
-      
-      return target(*args) if @setting_path.is_question_or_setter?
-      
+
+      return target(*args) if @setting_path.question_action_or_setter?
+
       self
     end
-    
+    # rubocop:enable all
+
     # Get the setting at the current path, if found.
     # (see LookupChain#lookup)
     def target *args
@@ -60,9 +88,10 @@ module Configurate
       @lookup_chain.lookup @setting_path, *args
     end
     alias_method :get, :target
-    
+
     private
-    COMMON_KEY_NAMES = [:key, :method]
+
+    COMMON_KEY_NAMES = %i[key method].freeze
 
     def target_respond_to? setting, include_private=false
       return false if COMMON_KEY_NAMES.include? setting

data/lib/configurate/setting_path.rb

@@ -1,4 +1,6 @@
-require 'forwardable'
+# frozen_string_literal: true
+
+require "forwardable"
 
 module Configurate
   # Class encapsulating the concept of a path to a setting
@@ -19,34 +21,40 @@ module Configurate
     def_delegators :@path, :empty?, :length, :size, :hsh
 
     # Whether the current path looks like a question or setter method
-    def is_question_or_setter?
-      is_question? || is_setter?
+    def question_action_or_setter?
+      question? || action? || setter?
     end
 
     # Whether the current path looks like a question method
-    def is_question?
+    def question?
       @path.last.to_s.end_with?("?")
     end
 
+    # Whether the current path looks like an action method
+    def action?
+      @path.last.to_s.end_with?("!")
+    end
+
     # Whether the current path looks like a setter method
-    def is_setter?
+    def setter?
       @path.last.to_s.end_with?("=")
     end
 
     def each
       return to_enum(:each) unless block_given?
+
       @path.each do |component|
         yield clean_special_characters(component)
       end
     end
 
-    [:join, :first, :last, :shift, :pop].each do |method|
+    %i[join first last shift pop].each do |method|
       define_method method do |*args|
         clean_special_characters @path.public_send(method, *args)
       end
     end
 
-    [:<<, :unshift, :push].each do |method|
+    %i[<< unshift push].each do |method|
       define_method method do |*args|
         @path.public_send method, *args.map(&:to_s)
       end
@@ -61,7 +69,11 @@ module Configurate
     end
 
     def inspect
-      "<SettingPath:#{object_id.to_s(16)} path=#{to_s}:#{@path.object_id.to_s(16)} setter=#{is_setter?} question=#{is_question?}>"
+      "<SettingPath:#{object_id.to_s(16)} "\
+      "path=#{self}:#{@path.object_id.to_s(16)} "\
+      "question=#{question?} "\
+      "action=#{action?} "\
+      "setter=#{setter?}>"
     end
 
     private

data/spec/configurate/lookup_chain_spec.rb

@@ -1,8 +1,10 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require "spec_helper"
 
 class InvalidConfigurationProvider; end
 class ValidConfigurationProvider
-  def lookup(setting, *args); end
+  def lookup(_setting, *_args); end
 end
 
 describe Configurate::LookupChain do
@@ -71,34 +73,34 @@ describe Configurate::LookupChain do
 
     it "converts numbers to strings" do
       allow(@provider[0]).to receive(:lookup).and_return(5)
-      expect(subject.lookup "foo").to eq "5"
+      expect(subject.lookup("foo")).to eq "5"
     end
 
     it "does not convert false to a string" do
       allow(@provider[0]).to receive(:lookup).and_return(false)
-      expect(subject.lookup "enable").to be_falsey
+      expect(subject.lookup("enable")).to be_falsey
     end
 
     it "converts 'true' to true" do
       allow(@provider[0]).to receive(:lookup).and_return("true")
-      expect(subject.lookup "enable").to be_truthy
+      expect(subject.lookup("enable")).to be_truthy
     end
 
     it "converts 'false' to false" do
       allow(@provider[0]).to receive(:lookup).and_return("false")
-      expect(subject.lookup "enable").to be_falsey
+      expect(subject.lookup("enable")).to be_falsey
     end
 
     it "returns the value unchanged if it can't be converted" do
       value = double
       allow(value).to receive(:respond_to?).with(:to_s).and_return(false)
       allow(@provider[0]).to receive(:lookup).and_return(value)
-      expect(subject.lookup "enable").to eq value
+      expect(subject.lookup("enable")).to eq value
     end
 
     it "returns nil if no value is found" do
-      @provider.each { |p| allow(p).to receive(:lookup).and_raise(Configurate::SettingNotFoundError) }
-      expect(subject.lookup "not.me").to be_nil
+      @provider.each {|p| allow(p).to receive(:lookup).and_raise(Configurate::SettingNotFoundError) }
+      expect(subject.lookup("not.me")).to be_nil
     end
   end
 end