confuse 1.0.0 → 1.1.0

data/README.md

@@ -21,22 +21,25 @@ Or install it yourself as:
 
 ## Usage
 
-Basic usage:
+# Basic usage
 
     config = Confuse.config do |conf|
-      conf.add_item :foo, :description => 'Foo', :default => 1
+      conf.add_item :foo
     end
 
     config[:foo]
+
+or
+
     config.foo
 
-Types:
+# Sources
 
 You can choose where and your config is stored by passing a :path variable to
 Confuse.config:
 
     config = Confuse.config :path => 'config.ini' do |conf|
-      conf.add_item :foo, :description => 'Foo', :default => 1
+      conf.add_item :foo
     end
 
 Confuse will attempt to work out the type of file from the extension (Supports
@@ -44,30 +47,45 @@ Confuse will attempt to work out the type of file from the extension (Supports
 passing in a :type option:
 
     config = Confuse.config :path => 'foo.conf' :type => :yaml do |conf|
-      conf.add_item :foo, :description => 'Foo', :default => 1
+      conf.add_item :foo
     end
 
 If no type or path is given, it will default to environment variables.
+Environment variables have an an extra option, which is the ability to provide
+a prefix:
 
-Environment variables have one extra feature, which is the ability to provide a
-prefix:
-
-
-    config = Confuse.config :prefix => 'FOO' :type => :yaml do |conf|
-      conf.add_item :foo, :description => 'Foo', :default => 1
+    config = Confuse.config :prefix => 'FOO' do |conf|
+      conf.add_item :foo
     end
 
 This means Confuse will lookup environment varialbles with that prefix with an
 underscore followed by the configuration name. If none is given, it will lookup
 environment variables as is.
 
-Namespaces:
+# Defaults
+
+You can give a config item a default value, which will be used in cases where
+none is set in the source.
+
+    config = Confuse.config do |conf|
+      conf.add_item :foo, :default => 1
+    end
+
+This can also be a proc that takes the config as an argument. This allows you
+to set a value based on what another item is set to.
+
+    config = Confuse.config do |conf|
+      conf.add_item :foo, :default => 'foo'
+      conf.add_item :bar, :default => proc { |c| "#{c.foo}_bar" }
+    end
+
+# Namespaces
 
 You can separate your configuration into different namespaces:
 
     config = Confuse.config :type => :env do |conf|
       conf.add_namespace :foo do |ns|
-        ns.add_item :foo, :description => 'Foo', :default => 1
+        ns.add_item :foo
       end
     end
 
@@ -81,22 +99,58 @@ Or a method call:
 
 However, beware of adding an item at the top level with the same name.
 
-Check:
+# Types
+
+You can specify the type of a configuration item.
+
+    config = Confuse.config do |conf|
+      conf.add_item :foo, :type => Fixnum
+    end
+
+This will ensure that any value is converted to the correct class when asked
+for, or an error raised if it is the wrong type and it can't be converted.
+
+If a default is given, the type will be derived from the class of the default,
+unless the default is a Proc.
+
+The following types are supported:
+- String
+- Fixnum
+- Float
+- Array
+- :bool (a special case, because TrueClass and FalseClass do not share a unique
+    common ancestor.)
+
+Arrays can be used in sources that don't support arrays by supplying a comma
+separated list.
+
+If you wish to add support for another type, or even custom types. You can
+register your own types if you wish:
+
+    Confuse::Converter.register <type> do |item|
+      ...
+    end
+
+The type can be anything, but it can only be derived from the default if a
+class is used.
+
+# Check
 
 If you want to make sure all your configuration items are in place before
 running the program you can call .check on it.
 
     config = Confuse.config do |conf|
-      conf.add_item :foo, :description => 'Foo', :default => 1
+      conf.add_item :foo
     end
 
     config.check
 
-If any of the items haven't been set, and don't have a default value, an
-exception will be thrown. If you don't care about certain variables, you can
-pass :required => false to them (or give them a default value).
+If any of the items haven't been set, and don't have a default value, or if an
+item is the incorrect type, an exception will be thrown. If you don't care about
+certain variables, you can pass :required => false to them (or give them a
+default value).
 
-Use a different source:
+# Use a different source
 
 If you want to use a source that isn't an ini file or yaml file, or environment
 variable. It is very easy to create your own one. It simply needs to be a class

data/lib/confuse.rb

@@ -8,6 +8,7 @@ require 'confuse/item'
 require 'confuse/definition'
 require 'confuse/namespace'
 require 'confuse/source'
+require 'confuse/converter'
 require 'confuse/errors'
 
 # Top level namespace for confuse gem

data/lib/confuse/config.rb

@@ -21,7 +21,13 @@ module Confuse
     end
 
     def lookup(namespace, key)
-      @source[namespace, key] || @definition.default(namespace, key)
+      unless (item = @definition.find_item(namespace, key))
+        raise Errors::Undefined.new(key)
+      end
+
+      value = @source[namespace, key] || item.default(self)
+
+      item.convert(value)
     end
 
     # check items have a value. Will raise Undefined error if a required item
@@ -33,5 +39,12 @@ module Confuse
         end
       end
     end
+
+    def to_hash
+      @definition.to_hash.reduce({}) do |a, (k, v)|
+        value_added = v.merge(:value => self[k])
+        a.merge({ k => value_added })
+      end
+    end
   end
 end

data/lib/confuse/converter.rb

@@ -0,0 +1,46 @@
+# coding: utf-8
+
+module Confuse
+  module Converter
+    class << self
+      def converters
+        @converters ||= { }
+      end
+
+      def register(key, &block)
+        converters[key] = block
+      end
+
+      def [](key)
+        converters[key]
+      end
+    end
+
+    register(String) { |item| item.to_s }
+
+    register Fixnum do |item|
+      raise Errors::Invalid unless /^\d*$/.match item.to_s
+      item.to_i
+    end
+
+    register Float do |item|
+      raise Errors::Invalid unless /^\d*(\.\d*)?$/.match item.to_s
+      item.to_f
+    end
+
+    register :bool do |item|
+      raise Errors::Invalid unless %w(true false).include? item.to_s
+      item.to_s == 'true'
+    end
+
+    register Array do |item|
+      if item.respond_to? :to_ary
+        item.to_ary
+      elsif item.include? ','
+        item.split(',')
+      else
+        raise Errors::Invalid
+      end
+    end
+  end
+end

data/lib/confuse/definition.rb

@@ -11,12 +11,8 @@ module Confuse
       !!find_item_by_name(name)
     end
 
-    def default(namespace, key)
-      (item = find_item(namespace, key)) && item.default
-    end
-
     def add_namespace(name, &block)
-      new_namespace = Namespace.new(&block)
+      new_namespace = Namespace.new(name, &block)
       namespaces[name.to_sym] = new_namespace
     end
 
@@ -26,7 +22,7 @@ module Confuse
 
     def namespaces
       @namespaces ||= {
-        @default_namespace => Namespace.new(&(Proc.new {}))
+        @default_namespace => Namespace.new(nil, &(Proc.new {}))
       }
     end
 
@@ -35,16 +31,20 @@ module Confuse
         [nil, name]
     end
 
+    def find_item(namespace, key)
+      (ns = find_namespace(namespace)) && ns[key]
+    end
+
+    def to_hash
+      @namespaces.reduce({}) { |a, (_k, v)| a.merge(v) }
+    end
+
     private
 
     def find_item_by_name(name)
       namespace, key = namespace_and_key(name)
     end
 
-    def find_item(namespace, key)
-      (ns = find_namespace(namespace)) && ns[key]
-    end
-
     def find_namespace(name)
       namespaces[name || @default_namespace]
     end

data/lib/confuse/errors.rb

@@ -8,5 +8,7 @@ module Confuse
         super
       end
     end
+
+    class Invalid < StandardError; end
   end
 end

data/lib/confuse/item.rb

@@ -6,15 +6,67 @@ module Confuse
     def initialize(key, opts = {})
       @key = key
       @default, @description = opts.values_at(:default, :description)
+
+      @converter = opts[:converter]
+      @type = opts[:type]
+
       @required = opts.key?(:required) ? opts[:required] : true
     end
 
-    attr_reader :description, :required
+    attr_reader :description, :required, :converter
+
+    def convert(value)
+      converter.call(value)
+    end
+
+    def default(config)
+      raise Errors::Undefined.new(@key) if @required && !@default
+
+      res = if @default.respond_to?(:call)
+              @default.call(config)
+            else
+              @default
+            end
+    end
+
+    def to_s
+      default = if @default && !@default.respond_to?(:call)
+                  "default: #{@default}"
+                else
+                  ''
+                end
+      "#{@key}:\t#{description} #{default}"
+    end
+
+    def to_hash
+      {
+        :description => @description,
+        :default => @default
+      }
+    end
+
+    private
+
+    def type
+      @type || type_from_default || String
+    end
+
+    def type_from_default
+      if @default
+        klass = @default.class
+        case @default
+        when TrueClass, FalseClass
+          :bool
+        when Proc
+          String
+        else
+          @default.class
+        end
+      end
+    end
 
-    def default
-      res = @default
-      raise Errors::Undefined.new(@key) if @required && !res
-      res
+    def converter
+      @converter ||= Converter[type]
     end
   end
 end

data/lib/confuse/namespace.rb

@@ -6,7 +6,8 @@ module Confuse
   class Namespace
     attr_reader :items
 
-    def initialize(&block)
+    def initialize(name, &block)
+      @name = name
       @items = {}
       block.call(self) if block_given?
     end
@@ -18,5 +19,12 @@ module Confuse
     def [](key)
       @items[key]
     end
+
+    def to_hash
+      @items.reduce({}) do |a, (k,v)|
+        key = @name ? :"#{@name}_#{k}" : k
+        a.merge({ key => v.to_hash })
+      end
+    end
   end
 end

data/lib/confuse/source/env.rb

@@ -8,7 +8,7 @@ module Confuse
       end
 
       def [](namespace, key)
-        lookup = key
+        lookup = key.to_s
         lookup = prepend(namespace, lookup) if namespace
         lookup = prepend(@prefix, lookup) if @prefix
 

data/lib/confuse/version.rb

@@ -2,5 +2,5 @@
 
 # Confuse version
 module Confuse
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/test/test_config.rb

@@ -35,11 +35,25 @@ class TestConfig < MiniTest::Unit::TestCase
 
   # raises undefined if an item hasn't been set, and has no default
   def test_get_default_from_definition
-    assert_nil @config.buz
+    assert_raises(Confuse::Errors::Undefined) { @config.buz }
   end
 
   # raises an error if any items are required and don't have defaults
   def test_check
     assert_raises(Confuse::Errors::Undefined) { @config.check }
   end
+
+  def test_to_hash
+    config = Confuse.config do |conf|
+      conf.add_item :foo, :description => 'foo', :default => 1
+      conf.add_namespace :bar do |ns|
+        ns.add_item :baz, :description => 'bar_baz', :default => 2
+      end
+    end
+
+    assert_equal(
+      { :foo => { :description => 'foo', :default => 1, :value => 1 },
+        :bar_baz => { :description => 'bar_baz', :default => 2, :value => 2 } },
+      config.to_hash)
+  end
 end

data/test/test_converter.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+class TestConverter < MiniTest::Unit::TestCase
+  def test_string
+    converter = Confuse::Converter[String]
+
+    assert_equal '1', converter.call(1)
+    assert_equal '1.0', converter.call(1.0)
+    assert_equal 'true', converter.call(true)
+    assert_equal 'false', converter.call(false)
+    assert_equal 'foo', converter.call('foo')
+  end
+
+  def test_fixnum
+    converter = Confuse::Converter[Fixnum]
+
+    assert_equal 1, converter.call(1)
+    assert_equal 1, converter.call('1')
+    assert_raises(Confuse::Errors::Invalid) { converter.call('1.0') }
+    assert_raises(Confuse::Errors::Invalid) { converter.call('1.0.0') }
+    assert_raises(Confuse::Errors::Invalid) { converter.call('foo') }
+  end
+
+  def test_float
+    converter = Confuse::Converter[Float]
+
+    assert_equal 1.0, converter.call(1.0)
+    assert_equal 1.0, converter.call(1)
+    assert_equal 1.0, converter.call('1')
+    assert_equal 1.0, converter.call('1.0')
+    assert_raises(Confuse::Errors::Invalid) { converter.call('1.0.0') }
+    assert_raises(Confuse::Errors::Invalid) { converter.call('foo') }
+  end
+
+  def test_bool
+    converter = Confuse::Converter[:bool]
+
+    assert_equal true, converter.call(true)
+    assert_equal false, converter.call(false)
+    assert_equal true, converter.call('true')
+    assert_equal false, converter.call('false')
+    assert_raises(Confuse::Errors::Invalid) { converter.call('foo') }
+  end
+
+  def test_array
+    converter = Confuse::Converter[Array]
+
+    assert_equal %w(foo bar), converter.call(%w(foo bar))
+    assert_equal %w(foo bar), converter.call('foo,bar')
+    assert_raises(Confuse::Errors::Invalid) { converter.call('foo') }
+  end
+end

data/test/test_definition.rb

@@ -11,6 +11,14 @@ module Confuse
       end
     end
 
+    def source
+      @source ||= Confuse.source
+    end
+
+    def config
+      @config ||= Confuse::Config.new(@definition, source)
+    end
+
     # can define a configuration item
     def test_define_item
       assert @definition.defines? :foo
@@ -21,12 +29,11 @@ module Confuse
       assert @definition.defines? :bar_foo
     end
 
-    def test_default
-      assert_equal 1, @definition.default(nil, :foo)
-    end
-
-    def test_default_for_namespaced_item
-      assert_equal 1, @definition.default(:bar, :foo)
+    def test_to_hash
+      assert_equal(
+        { :foo => { :description => nil, :default => 1 },
+          :bar_foo => { :description => 'test', :default => 1 } },
+        @definition.to_hash)
     end
   end
 end

data/test/test_item.rb

@@ -2,11 +2,12 @@
 
 class TestItem < MiniTest::Unit::TestCase
   def setup
-    @item = Confuse::Item.new(:foo, :default => 1, :description => 'Description')
+    @item = Confuse::Item.new(:foo, :default => 1,
+                                    :description => 'Description')
   end
 
   def test_sets_the_default_value
-    assert_equal 1, @item.default
+    assert_equal 1, @item.default(nil)
   end
 
   def test_sets_the_description
@@ -16,6 +17,23 @@ class TestItem < MiniTest::Unit::TestCase
   def test_required_item
     item = Confuse::Item.new(:foo, :description => 'required!',
                                    :required => true)
-    assert_raises(Confuse::Errors::Undefined) { item.default }
+    assert_raises(Confuse::Errors::Undefined) { item.default(nil) }
+  end
+
+  def test_proc_as_default
+    mock_conf = Class.new do
+      def bar
+        'bar'
+      end
+    end.new
+
+    item = Confuse::Item.new(:foo, :default => proc { |c| c.bar })
+
+    assert_equal 'bar', item.default(mock_conf)
+  end
+
+  def test_to_hash
+    assert_equal({ :description => 'Description', :default => 1 },
+                 @item.to_hash)
   end
 end

data/test/test_namespace.rb

@@ -6,11 +6,35 @@ require 'confuse'
 # Test {Confuse::Namespace}
 class TestNamespace < MiniTest::Unit::TestCase
   def setup
-    @namespace = Confuse::Namespace.new
+    @namespace = Confuse::Namespace.new(nil)
   end
 
   def test_add_an_item
     @namespace.add_item(:foo, :default => :foo, :description => 'Test')
     refute_nil @namespace[:foo]
   end
+
+  def test_to_hash
+    namespace = Confuse::Namespace.new(nil) do |ns|
+      ns.add_item :foo, :description => 'how many foos?', :default => 1
+      ns.add_item :bar, :description => 'how many bars?', :default => 2
+    end
+
+    assert_equal(
+      { :foo => { :description => 'how many foos?', :default => 1 },
+        :bar => { :description => 'how many bars?', :default => 2 } },
+      namespace.to_hash)
+  end
+
+  def test_to_hash_named_namespace
+    namespace = Confuse::Namespace.new(:foo) do |ns|
+      ns.add_item :foo, :description => 'how many foos?', :default => 1
+      ns.add_item :bar, :description => 'how many bars?', :default => 2
+    end
+
+    assert_equal(
+      { :foo_foo => { :description => 'how many foos?', :default => 1 },
+        :foo_bar => { :description => 'how many bars?', :default => 2 } },
+      namespace.to_hash)
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: confuse
 version: !ruby/object:Gem::Version 
-  hash: 23
+  hash: 19
   prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 0
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors: 
 - Tom Chipchase
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-09-15 00:00:00 Z
+date: 2014-09-16 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: inifile
@@ -98,6 +98,7 @@ files:
 - example/yaml_example.rb
 - lib/confuse.rb
 - lib/confuse/config.rb
+- lib/confuse/converter.rb
 - lib/confuse/definition.rb
 - lib/confuse/errors.rb
 - lib/confuse/item.rb
@@ -110,6 +111,7 @@ files:
 - lib/confuse/version.rb
 - test/test_config.rb
 - test/test_confuse.rb
+- test/test_converter.rb
 - test/test_definition.rb
 - test/test_item.rb
 - test/test_key_splitter.rb
@@ -150,6 +152,7 @@ summary: A DSL for defining configuration options in classes
 test_files: 
 - test/test_config.rb
 - test/test_confuse.rb
+- test/test_converter.rb
 - test/test_definition.rb
 - test/test_item.rb
 - test/test_key_splitter.rb