configurate 0.0.1

data/lib/configurate.rb

@@ -0,0 +1,69 @@
+
+require 'configurate/lookup_chain'
+require 'configurate/provider'
+require 'configurate/proxy'
+
+
+# A flexible and extendable configuration system.
+# The calling logic is isolated from the lookup logic
+# through configuration providers, which only requirement
+# is to define the +#lookup+ method and show a certain behavior on that.
+# The providers are asked in the order they were added until one provides
+# a response. This allows to even add multiple providers of the same type,
+# you never easier defined your default configuration parameters.
+# There are no class methods used, you can have an unlimited amount of
+# independent configuration sources at the same time.
+#
+# See {Settings} for a quick start.
+module Configurate
+  # This is your main entry point. Instead of lengthy explanations
+  # let an example demonstrate its usage:
+  # 
+  #     require Rails.root.join('lib', 'configuration')
+  #     
+  #     AppSettings = Configuration::Settings.create do
+  #       add_provider Configuration::Provider::Env
+  #       add_provider Configuration::Provider::YAML, '/etc/app_settings.yml',
+  #                    namespace: Rails.env, required: false
+  #       add_provider Configuration::Provider::YAML, 'config/default_settings.yml'
+  #       
+  #       extend YourConfigurationMethods
+  #     end
+  #
+  #     AppSettings.setup_something if AppSettings.something.enable?
+  #
+  # Please also read the note at {Proxy}!
+  class Settings
+  
+    attr_reader :lookup_chain
+    
+    undef_method :method # Remove possible conflicts with common setting names
+    
+    # @!method lookup(setting)
+    #   (see LookupChain#lookup)
+    # @!method add_provider(provider, *args)
+    #   (see LookupChain#add_provider)
+    # @!method [](setting)
+    # (see LookupChain#[])
+    def method_missing(method, *args, &block)
+      return @lookup_chain.send(method, *args, &block) if [:lookup, :add_provider, :[]].include?(method)
+      
+      Proxy.new(@lookup_chain).send(method, *args, &block)
+    end
+    
+    def initialize
+      @lookup_chain = LookupChain.new
+      $stderr.puts "Warning you called Configuration::Settings.new with a block, you really meant to call #create" if block_given?
+    end
+    
+    # Create a new configuration object
+    # @yield the given block will be evaluated in the context of the new object
+    def self.create(&block)
+      config = self.new
+      config.instance_eval(&block) if block_given?
+      config
+    end
+  end
+  
+  class SettingNotFoundError < RuntimeError; end
+end

data/lib/configurate/lookup_chain.rb

@@ -0,0 +1,65 @@
+module Configurate
+  # This object builds a chain of configuration providers to try to find
+  # a setting.
+  class LookupChain
+    def initialize
+      @provider = []
+    end
+    
+    # Add a provider to the chain. Providers are tried in the order
+    # they are added, so the order is important.
+    #
+    # @param provider [#lookup]
+    # @param *args the arguments passed to the providers constructor
+    # @raise [ArgumentError] if an invalid provider is given
+    # @return [void]
+    def add_provider(provider, *args)
+      unless provider.respond_to?(:instance_methods) && provider.instance_methods.include?(:lookup)
+        raise ArgumentError, "the given provider does not respond to lookup"
+      end
+      
+      @provider << provider.new(*args)
+    end
+    
+    
+    # Tries all providers in the order they were added to provide a response
+    # for setting.
+    #
+    # @param setting [#to_s] settings should be underscore_case,
+    #   nested settings should be separated by a dot
+    # @param *args further args passed to the provider
+    # @return [Array,String,Boolean,nil] whatever the provider provides
+    #   is casted to a {String}, except for some special values
+    def lookup(setting, *args)
+      setting = setting.to_s
+
+      @provider.each do |provider|
+        begin
+          return special_value_or_string(provider.lookup(setting, *args))
+        rescue SettingNotFoundError; end
+      end
+      
+      nil
+    end
+    alias_method :[], :lookup
+    
+    private 
+    
+    def special_value_or_string(value)
+      if [TrueClass, FalseClass, NilClass, Array, Hash].include?(value.class)
+        return value
+      elsif value.is_a?(String)
+        return case value.strip
+          when "true" then true
+          when "false" then false
+          when "", "nil" then nil
+          else value
+        end
+      elsif value.respond_to?(:to_s)
+        return value.to_s
+      else
+        return value
+      end
+    end
+  end
+end

data/lib/configurate/provider.rb

@@ -0,0 +1,19 @@
+module Configurate; module Provider
+  # This provides a basic {#lookup} method for other providers to build
+  # upon. Childs are expected to define +lookup_path(path, *args)+ where
+  # +path+ will be passed an array of settings generated by splitting the
+  # called setting at the dots. The method should return nil if the setting
+  # wasn't found and {#lookup} will raise an {SettingNotFoundError} in that
+  # case.
+  class Base
+    def lookup(setting, *args)
+      result = lookup_path(setting.split("."), *args)
+      return result unless result.nil?
+      raise Configurate::SettingNotFoundError, "The setting #{setting} was not found"
+    end
+  end
+end; end
+
+require 'configurate/provider/yaml'
+require 'configurate/provider/env'
+require 'configurate/provider/dynamic'

data/lib/configurate/provider/dynamic.rb

@@ -0,0 +1,24 @@
+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
+    
+    def lookup_path(settings_path, *args)
+      key = settings_path.join(".")
+      
+      if key.end_with?("=") && args.length > 0
+        key = key.chomp("=")
+        value = args.first
+        value = value.get if value.respond_to?(:_proxy?) && value._proxy?
+        @settings[key] = value
+      end
+      
+      @settings[key]
+    end
+  end
+end; end

data/lib/configurate/provider/env.rb

@@ -0,0 +1,14 @@
+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+, replacing all dots in the setting
+  # and upcasing the result. If an value contains +,+ it's split at them
+  # and returned as array.
+  class Env < Base
+    def lookup_path(settings_path, *args)
+      value = ENV[settings_path.join("_").upcase]
+      value = value.split(",") if value && value.include?(",")
+      value
+    end
+  end
+end; end

data/lib/configurate/provider/yaml.rb

@@ -0,0 +1,52 @@
+require 'yaml'
+
+module Configurate; module Provider
+  # This provider tries to open a YAML file and does in 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.has_key?(:required) ? opts.delete(:required) : true
+      
+      @settings = ::YAML.load_file(file)
+      
+      namespace = opts.delete(:namespace)
+      unless namespace.nil?
+        actual_settings = lookup_in_hash(namespace.split("."), @settings)
+        unless actual_settings.nil?
+          @settings = actual_settings
+        else
+          raise ArgumentError, "Namespace #{namespace} not found in #{file}" if required
+        end
+      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(settings_path, *args)
+      lookup_in_hash(settings_path, @settings)
+    end
+    
+    private
+    
+    def lookup_in_hash(setting_path, hash)
+      setting = setting_path.shift
+      if hash.has_key?(setting)
+        if setting_path.length > 0 && hash[setting].is_a?(Hash)
+          return lookup_in_hash(setting_path, hash[setting]) if setting.length > 1
+        else
+          return hash[setting]
+        end
+      end
+    end
+  end
+end; end

data/lib/configurate/proxy.rb

@@ -0,0 +1,76 @@
+module Configurate
+  # Proxy object to support nested settings
+  # Cavehat: Since this is always true, adding a ? at the end
+  # returns the value, if found, instead of the proxy object.
+  # So instead of +if settings.foo.bar+ use +if settings.foo.bar?+
+  # to check for boolean values, +if settings.foo.bar.nil?+ to
+  # check for nil values, +if settings.foo.bar.present?+ to check for
+  # empty values if you're in Rails and call {#get} to actually return the value,
+  # commonly when doing +settings.foo.bar.get || 'default'+. If a setting
+  # ends with +=+ is too called directly, just like with +?+.
+  class Proxy < BasicObject
+    COMMON_KEY_NAMES = [:key, :method]
+    
+    # @param lookup_chain [#lookup]
+    def initialize(lookup_chain)
+      @lookup_chain = lookup_chain
+      @setting = ""
+    end
+    
+    def !
+      !self.get
+    end
+    
+    def !=(other)
+      self.get != other
+    end
+    
+    def ==(other)
+      self.get == other
+    end
+    
+    def _proxy?
+      true
+    end
+    
+    def respond_to?(method, include_private=false)
+      method == :_proxy? || self.get.respond_to?(method, include_private)
+    end
+    
+    def send(*args, &block)
+      self.__send__(*args, &block)
+    end
+    
+    def method_missing(setting, *args, &block)
+      unless COMMON_KEY_NAMES.include? setting
+        target = self.get
+        if !(target.respond_to?(:_proxy?) && target._proxy?) && target.respond_to?(setting)
+          return target.send(setting, *args, &block)
+        end
+      end
+
+      setting = setting.to_s
+
+      self.append_setting(setting)
+      
+      return self.get(*args) if setting.end_with?("?") ||  setting.end_with?("=")
+      
+      self
+    end
+    
+    # Get the setting at the current path, if found.
+    # (see LookupChain#lookup)
+    def get(*args)
+      setting = @setting[1..-1]
+      return unless setting
+      val = @lookup_chain.lookup(setting.chomp("?"), *args)
+      val
+    end
+    
+    protected
+    def append_setting(setting)
+      @setting << "."
+      @setting << setting
+    end
+  end
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: configurate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonne Haß
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-30 00:00:00.000000000 Z
+dependencies: []
+description: Configurate is a flexible configuration system that can read settings
+  from multiple sources at the same time.
+email: me@mrzyx.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/configurate/provider/env.rb
+- lib/configurate/provider/yaml.rb
+- lib/configurate/provider/dynamic.rb
+- lib/configurate/proxy.rb
+- lib/configurate/lookup_chain.rb
+- lib/configurate/provider.rb
+- lib/configurate.rb
+homepage: https://github.com/MrZYX/configurate
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Flexbile configuration system
+test_files: []