confuse 0.1.8 → 1.0.0

data/example/001_simple_example.ini

@@ -1,3 +0,0 @@
-[default]
-foo = 10
-bar = 20

data/example/001_simple_example.rb

@@ -1,18 +0,0 @@
-require 'configuration/configurable'
-
-# An example of adding configuration options to a class.
-class SimpleExample
-  configurable
-
-  config_path 'example/001_simple_example.ini'
-
-  define :foo do
-    description   "How many Foo's are there?"
-    type          :integer
-    default       1
-  end
-
-end
-
-example = SimpleExample.new
-puts example.foo

data/example/002_namespace_example.rb

@@ -1,29 +0,0 @@
-require 'configuration/configurable'
-
-# An example of adding configuration options to a class, seperated by
-# namespaces.
-class NamespaceExample
-  configurable
-
-  config_path 'example/002_namespace_example.ini'
-
-  define :bar do
-    description 'foo_bar'
-    type :integer
-    default 1
-  end
-
-  namespace :foo do
-    define :bar do
-      description 'bar_foo'
-      type :string
-      default 'Hello, world!'
-    end
-  end
-end
-
-example = NamespaceExample.new
-puts example.config.inspect
-puts example.bar
-puts example.config[:foo_bar]
-puts example.foo[:bar]

data/example/003_config_subclass_instance.ini

@@ -1,2 +0,0 @@
-[default]
-foo = 1

data/example/003_config_subclass_instance_example.rb

@@ -1,9 +0,0 @@
-require 'confuse'
-
-class ExampleConfig < Confuse::ConfigBase
-  define :foo do
-    default 10
-  end
-end
-
-puts ExampleConfig.new('example/003_config_subclass_instance.ini').foo

data/example/004_configured_by.rb

@@ -1,26 +0,0 @@
-require 'configuration/configurable'
-
-module ExampleConfig
-  extend Configuration::ConfigMixin
-  extend Configuration::DSL
-
-  define :conf do
-    default 2
-  end
-end
-
-class Foo
-  configured_by ExampleConfig
-
-  default_namespace :foo
-
-  define :bar do
-    default 1
-  end
-
-end
-
-foo = Foo.new
-puts foo.config[:conf]
-puts foo.bar
-

data/lib/confuse/config_item.rb

@@ -1,38 +0,0 @@
-module Confuse
-  # A {ConfigItem} is a class for storing a single piece of config. It has a
-  # key, a type, a description, and a default value.
-  class ConfigItem
-    attr_reader :key
-    attr_writer :value
-    attr_reader :default_value
-
-    def initialize(name, &block)
-      @key = name
-      instance_eval(&block) unless block.nil?
-    end
-
-    def description(description = nil)
-      @description = description unless description.nil?
-      @description
-    end
-
-    def type(type = nil)
-      @type = type unless type.nil?
-      @type
-    end
-
-    def default(value = nil, &block)
-      @default_value = value unless value.nil?
-      @default_value = block unless block.nil?
-    end
-
-    def value=(val)
-      @value = val
-    end
-
-    def value
-      @value || @default_value
-    end
-  end
-end
-

data/lib/confuse/config_mixin.rb

@@ -1,135 +0,0 @@
-require 'confuse/namespace'
-require 'inifile'
-require 'yaml'
-
-module Confuse
-  # Mixin for configuration.
-  module ConfigMixin
-    def namespaces
-      @namespaces ||= {}
-    end
-
-    def load_namespaces(new_namespaces)
-      new_namespaces.each do |key, value|
-        existing = namespaces[key]
-        existing ? existing.merge!(value) : namespaces[key] = value.clone
-      end
-      @foo = true
-    end
-
-    def read_files(file_paths)
-      Array(file_paths).map do |path|
-        if File.directory?(path)
-          load_config_dir(path)
-        elsif File.exists?(path)
-          load_config_file(path)
-        end
-      end.flatten.compact.each { |c| mixin_config!(c) }
-    end
-
-    def [](key)
-      namespace = find_namespace(key) || :default
-      rest_of_key = rest_of_key(key, namespace)
-      ns = namespaces[namespace]
-      return ns unless rest_of_key
-      ns[rest_of_key, self]
-    end
-
-    def []=(key, value)
-      puts 'WARNING: changing config after it has been set!'
-      mixin_config!({ key => value })
-    end
-
-    def to_hash
-      namespaces.reduce({}) do |memo, (name, namespace)|
-        namespace.keys.each do |key|
-          if name != :default
-            memo[:"#{name}_#{key}"] = namespace[key, self]
-          else
-            memo[:"#{key}"] = namespace[key, self]
-          end
-        end
-        memo
-      end
-    end
-
-    # We allow the namespace and the key to be concatenated with an '_', so this
-    # method is to search the possible substrings that could make up the
-    # namespace for a key.
-    #
-    # This does not guarentee that the suffix of the namespace that is found is
-    # a valid key in that namespace.
-    #
-    # @param [Symbol] key to search
-    def find_namespace(key)
-      until key.to_s.empty? || @namespaces[key.to_sym]
-        key = (s = key.to_s)[0, s.rindex('_') || 0]
-      end
-      key.to_s.empty? ? nil : key.to_sym
-    end
-
-    # Once we've found the namespace, we want to find the rest of the string
-    # to use as the rest of the key. If the namespace isn't a substring of the
-    # key (e.g. :default), we return the key unaltered.
-    #
-    # @param [Symbol] key The full key
-    # @param [Symbol] namespace The substring of the key that is the
-    # namespace.
-    def rest_of_key(key, namespace)
-      key_s = key.to_s
-      namespace_s = namespace.to_s
-      return nil if key_s == namespace_s
-      index = key_s.index(namespace_s) && (namespace_s.length + 1)
-      key_s[index || 0, key_s.length].to_sym
-    end
-
-    def load_config_dir(config_dir)
-      Dir[config_dir + '/*.{ini,conf,yaml}'].map do |conf_file|
-        load_config_file(conf_file)
-      end
-    end
-
-    def load_config_file(conf_file)
-      conf = load_ini(conf_file) || load_yaml(conf_file)
-      raise "Can't parse #{conf_file}" unless conf
-      conf
-    end
-
-    def mixin_config!(config)
-      config.each do |key, value|
-        namespace_name = find_namespace(key) || :default
-        namespace = @namespaces[namespace_name]
-        if value.respond_to?(:keys)
-          # if its a hash, set each key in the hash as a config item in the
-          # namespace
-          value.each { |k, v| namespace[k] = v }
-        else
-          # otherwise, set it directly in the namespace
-          namespace[rest_of_key(key, namespace_name)] = value
-        end
-      end
-    end
-
-    def load_ini(file)
-      begin
-        # make sure they keys are ruby symbols
-        symbolise_hash_keys(IniFile.load(file).to_h)
-      rescue IniFile::Error
-        nil
-      end
-    end
-
-    def symbolise_hash_keys(hash)
-      hash.reduce({}) do |memo, (key, val)|
-        memo[key.to_sym] =
-        val.respond_to?(:reduce) ? symbolise_hash_keys(val) : val
-      memo
-      end
-    end
-
-    def load_yaml(file)
-      YAML.load(File.read(file))
-    end
-
-  end
-end

data/lib/confuse/configurable.rb

@@ -1,15 +0,0 @@
-require 'confuse'
-
-# Monkey patch class to easily allow a class to be configurable.
-class Class
-  def configurable
-    extend Confuse::DSL
-    include Confuse::InstanceMethods
-  end
-
-  def configured_by(config)
-    configurable
-    @configured_by = config
-  end
-end
-

data/lib/confuse/dsl.rb

@@ -1,68 +0,0 @@
-require 'confuse/config'
-
-module Confuse
-  # DSL for setting up a configurable class
-  module DSL
-    attr_reader :configured_by
-
-    def configured_by(config = Config)
-      @configured_by ||= config
-    end
-
-    def default_namespace(namespace = :default)
-      @default_namespace ||= namespace
-    end
-
-    def config_path(*paths)
-      @config_path ||= []
-      @config_path.concat paths
-    end
-
-    def namespaces
-      @namespaces ||= {
-        default_namespace => Namespace.new(&(Proc.new { }))
-      }
-    end
-
-    def define(name, &block)
-      namespaces[default_namespace].define(name, &block)
-      getter(name, default_namespace)
-    end
-
-    def namespace(name, &block)
-      new_namespace = Namespace.new(&block)
-      if namespaces[name.to_sym]
-        namespaces[name.to_sym].merge! new_namespace
-      else
-        namespaces[name.to_sym] = new_namespace
-      end
-      getter(name)
-    end
-
-    def getter(name, namespace = nil)
-      class_eval do
-        if namespace.nil?
-          define_method(name) do
-            config[name]
-          end
-        else
-          define_method(name) do
-            config[namespace][name, config]
-          end
-        end
-      end
-    end
-
-  end
-
-  # Instance methods for getting the defined configuration from an instance of
-  # a configured class.
-  module InstanceMethods
-    # Lazilly create the config object when it is first requested.
-    def config
-      self.class.configured_by.load_namespaces(self.class.namespaces)
-      self.class.configured_by.read_files(self.class.config_path)
-      self.class.configured_by
-    end
-  end
-end

data/test/test_config_base.rb

@@ -1,37 +0,0 @@
-require 'minitest/autorun'
-require 'confuse'
-
-class Foo < Confuse::ConfigBase
-  define :foo do
-    default 'foo'
-    type :string
-    description 'foo'
-  end
-end
-
-class TestConfigBase < MiniTest::Unit::TestCase
-  # This is easier to test with an instance of a config object, rather than as
-  # part of the test for the module where other tests can modify the model.
-  def test_params_hash
-    assert_equal({ :default_foo  => { :type => :string, :doc => 'foo',
-                                      :default => 'foo' } },
-                 Foo.params_hash)
-  end
-
-  def test_can_specify_config_options_on_initialize
-    config = Foo.new(:conf => { :foo => 'bar' })
-
-    assert_equal 'bar', config[:foo]
-  end
-
-  def test_two_instances_can_exist_with_different_values
-    # instatiate two versions of the config
-    config1 = Foo.new
-    config2 = Foo.new(:conf => { :foo => 'bar' })
-
-    # assert config1 and config2 are different
-    assert_equal 'foo', config1[:foo]
-    assert_equal 'bar', config2[:foo]
-  end
-end
-