configurate 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b50fb25fde4dc42ae6cdc150bb6042fea6c0cd09
+  data.tar.gz: 3a9b3988d4d030c58a14d58c116fdb6a3682629c
+SHA512:
+  metadata.gz: b30760168a9e5da90281dd3756f661c05ef4db4f27a8cce9eb08c1d3fb3cf2ad609992af0685511ad027eb6398665a12c07b87f6e508e08cbe05643a740abcd5
+  data.tar.gz: 387ce8d7237c183a3b214b9308d5c3227dfef1dbeea7b1ff97c208bceae2888483f2efce0aae60190a49c81e64e27ed20da6897741ec69e82078cfe4454677da

checksums.yaml.gz.asc

@@ -0,0 +1,11 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.19 (GNU/Linux)
+
+iQEcBAABAgAGBQJRaxYFAAoJEPNH4OtHrHDWk80H/jAcCNmTYyFrUrm6lK3kOlo3
+SnhKm+xDqB/izEJD7EZMtCEPVeC4ArrNbrN10PJZ6mQgHApenBJ5CDXqFdlTIT0b
+n+qFL+kcfK0abBrJz5g0Sv4wS5rCDWWYZLl4CiGLmbalQRB6fSsWiXFNlBVawt7l
+88ZGE8vL8eR/F0JycjiE6fjryvg8qplZiC7NzqkpSmN0hxzqc5leHY7JoYgAP4PN
+cloCT0I3iUH+fCqez8ujX3NX2RdURVfL+bilLf4LROOlaAvZgYYjngWUOWFnv3AJ
+e9+JXSgNme9zmuTA/DtD29r9CSHf0Sc7EO18vJrJTJ6a+Dv9Qe/2IwBYWkmibdo=
+=rgFX
+-----END PGP SIGNATURE-----

data.tar.gz.asc

@@ -0,0 +1,11 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.19 (GNU/Linux)
+
+iQEcBAABAgAGBQJRaxYFAAoJEPNH4OtHrHDWpOIH/jkbHhYBNcCMizn4WTWWKvx+
+rIUozwKicxON4uebRoP6RIuzKQzhSs1mYZbQebo4qY/EVAI2zU+ysuyhCJlsELZG
+Au/Lh3xYCS7OIP3KGVCo8eblenEG0OjaeDIfe08TuoZumx9Hv39jmK6uRG9jvCBX
+tEZmw1T2bDn2uDOaolUD7BiMZgXYigH4RIZcpsd7qb7nniyHH7ULET2ofSWQpK3a
+GGHV6yZdtbgnpt3f4o3dFKF4+aEYmWZ/deJbCwsvA9rNIIDfQZzS91sNCQAPp7RK
+y8ryytPhGb2hCUqgNLZpNg/cfSwgkU3PRmcq2q8FxHvu9qCxafgmSYq4LWy70tA=
+=99eN
+-----END PGP SIGNATURE-----

data/lib/configurate.rb

@@ -1,4 +1,5 @@
 
+require 'configurate/setting_path'
 require 'configurate/lookup_chain'
 require 'configurate/provider'
 require 'configurate/proxy'
@@ -6,12 +7,12 @@ require 'configurate/proxy'
 
 # A flexible and extendable configuration system.
 # The calling logic is isolated from the lookup logic
-# through configuration providers, which only requirement
+# through configuration providers, whose 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
+# There is no shared state, you can have an unlimited amount of
 # independent configuration sources at the same time.
 #
 # See {Settings} for a quick start.
@@ -19,7 +20,7 @@ module Configurate
   # This is your main entry point. Instead of lengthy explanations
   # let an example demonstrate its usage:
   # 
-  #     require Rails.root.join('lib', 'configuration')
+  #     require 'configuration_methods'
   #     
   #     AppSettings = Configurate::Settings.create do
   #       add_provider Configurate::Provider::Env
@@ -40,15 +41,19 @@ module Configurate
     undef_method :method # Remove possible conflicts with common setting names
     
     # @!method lookup(setting)
-    #   (see LookupChain#lookup)
+    # (see {LookupChain#lookup})
+
     # @!method add_provider(provider, *args)
-    #   (see LookupChain#add_provider)
+    # (see {LookupChain#add_provider})
+
     # @!method [](setting)
-    # (see LookupChain#[])
+    # (see {LookupChain#[]})
+
+    # See description and {#lookup}, {#[]} and {#add_provider}
     def method_missing(method, *args, &block)
-      return @lookup_chain.send(method, *args, &block) if [:lookup, :add_provider, :[]].include?(method)
+      return @lookup_chain.public_send(method, *args, &block) if [:lookup, :add_provider, :[]].include?(method)
       
-      Proxy.new(@lookup_chain).send(method, *args, &block)
+      Proxy.new(@lookup_chain).public_send(method, *args, &block)
     end
     
     def initialize

data/lib/configurate/lookup_chain.rb

@@ -1,12 +1,12 @@
 module Configurate
   # This object builds a chain of configuration providers to try to find
-  # a setting.
+  # the value of a setting.
   class LookupChain
     def initialize
       @provider = []
     end
     
-    # Add a provider to the chain. Providers are tried in the order
+    # Adds a provider to the chain. Providers are tried in the order
     # they are added, so the order is important.
     #
     # @param provider [#lookup]
@@ -25,14 +25,13 @@ module Configurate
     # 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
+    # @param setting [SettingPath,String] nested settings as strings should
+    #   be separated by a dot
+    # @param ... further args passed to the provider
+    # @return [Array,Hash,String,Boolean,nil] whatever the responding
+    #   provider provides is casted to a {String}, except for some special values
     def lookup(setting, *args)
-      setting = setting.to_s
-
+      setting = SettingPath.from_string(setting) if setting.is_a? String
       @provider.each do |provider|
         begin
           return special_value_or_string(provider.lookup(setting, *args))

data/lib/configurate/provider.rb

@@ -1,15 +1,14 @@
 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
+  # upon. Childs are expected to define +lookup_path(path, *args)+.
+  # 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)
+    def lookup(*args)
+      result = lookup_path(*args)
       return result unless result.nil?
-      raise Configurate::SettingNotFoundError, "The setting #{setting} was not found"
+      raise Configurate::SettingNotFoundError, "The setting #{args.first} was not found"
     end
   end
 end; end

data/lib/configurate/provider/dynamic.rb

@@ -8,11 +8,10 @@ module Configurate; module Provider
       @settings = {}
     end
     
-    def lookup_path(settings_path, *args)
-      key = settings_path.join(".")
+    def lookup_path(setting_path, *args)      
+      key = setting_path.to_s
       
-      if key.end_with?("=") && args.length > 0
-        key = key.chomp("=")
+      if setting_path.is_setter? && args.length > 0
         value = args.first
         value = value.get if value.respond_to?(:_proxy?) && value._proxy?
         @settings[key] = value

data/lib/configurate/provider/env.rb

@@ -1,14 +1,16 @@
 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.
+  # 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(settings_path, *args)
-      value = ENV[settings_path.join("_").upcase]
-      value = value.dup unless value.nil?
-      value = value.split(",") if value && value.include?(",")
+    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
   end

data/lib/configurate/provider/yaml.rb

@@ -1,7 +1,7 @@
 require 'yaml'
 
 module Configurate; module Provider
-  # This provider tries to open a YAML file and does in nested lookups
+  # 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
@@ -13,27 +13,30 @@ module Configurate; module Provider
     # @raise [Errno:ENOENT] if the file isn't found
     def initialize(file, opts = {})
       @settings = {}
-      required = opts.has_key?(:required) ? opts.delete(:required) : true
+      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?
+        namespace = SettingPath.from_string(namespace)
+        actual_settings = lookup_in_hash(namespace, @settings)
+        if !actual_settings.nil?
           @settings = actual_settings
+        elsif required
+          raise ArgumentError, "Namespace #{namespace} not found in #{file}"
         else
-          raise ArgumentError, "Namespace #{namespace} not found in #{file}" if required
+          $stderr.puts "WARNING: Namespace #{namespace} not found in #{file}"
         end
       end
     rescue Errno::ENOENT => e
-      $stderr.puts "WARNING: configuration file #{file} not found, ensure it's present"
+      $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)
+    def lookup_path(setting_path, *args)
+      lookup_in_hash(setting_path, @settings)
     end
     
     private
@@ -42,7 +45,7 @@ module Configurate; module Provider
       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
+          return lookup_in_hash(setting_path, hash[setting]) if setting.length >= 1
         else
           return hash[setting]
         end

data/lib/configurate/proxy.rb

@@ -1,32 +1,34 @@
 module Configurate
   # Proxy object to support nested settings
-  # Cavehat: Since this is always true, adding a ? at the end
+  #
+  # *Cavehats*: Since this object 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 +?+.
+  # check for nil values and of course you can do +if settings.foo.bar.present?+ to check for
+  # empty values if you're in Rails. Call {#get} to actually return the value,
+  # commonly when doing +settings.foo.bar.get || "default"+. Also don't
+  # use this in case statements since +Module#===+ can't be fooled, again
+  # call {#get}.
+  #
+  # If a setting ends with +=+ it's 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 = ""
+      @setting_path = SettingPath.new
     end
     
     def !
-      !self.get
+      !target
     end
     
     def !=(other)
-      self.get != other
+      target != other
     end
     
     def ==(other)
-      self.get == other
+      target == other
     end
     
     def _proxy?
@@ -34,43 +36,43 @@ module Configurate
     end
     
     def respond_to?(method, include_private=false)
-      method == :_proxy? || self.get.respond_to?(method, include_private)
+      method == :_proxy? || target.respond_to?(method, include_private)
     end
     
     def send(*args, &block)
-      self.__send__(*args, &block)
+      __send__(*args, &block)
     end
+    alias_method :public_send, :send
     
     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
+      return target.public_send(setting, *args, &block) if target_respond_to? setting
 
-      setting = setting.to_s
-
-      self.append_setting(setting)
+      @setting_path << setting
       
-      return self.get(*args) if setting.end_with?("?") ||  setting.end_with?("=")
+      return target(*args) if @setting_path.is_question_or_setter?
       
       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
+    def target(*args)
+      return if @setting_path.empty?
+
+      @lookup_chain.lookup(@setting_path, *args)
     end
+    alias_method :get, :target
     
-    protected
-    def append_setting(setting)
-      @setting << "."
-      @setting << setting
+    private
+    COMMON_KEY_NAMES = [:key, :method]
+
+    def target_respond_to?(setting)   
+      return false if COMMON_KEY_NAMES.include? setting
+
+      value = target
+      return false if value.respond_to?(:_proxy?) && value._proxy?
+
+      value.respond_to?(setting)
     end
   end
 end

data/lib/configurate/setting_path.rb

@@ -0,0 +1,30 @@
+module Configurate
+  # Class encapsulating the concept of a path to a setting
+  class SettingPath < Array
+
+    # Create a path from the string format (+foo.bar+).
+    # @param path [String]
+    # @return [SettingPath]
+    def self.from_string(path)
+      SettingPath.new(path.split("."))
+    end
+
+    # Whether the current path looks like a question or setter method
+    def is_question_or_setter?
+      last.to_s.end_with?("?") || is_setter?
+    end
+
+    # Whether the current path looks like a setter method
+    def is_setter?
+      last.to_s.end_with?("=")
+    end
+
+    def to_s
+      join(".").chomp("?").chomp("=")
+    end
+
+    def inspect
+      "<SettingPath path=#{to_s}>"
+    end
+  end
+end

data/spec/configurate/lookup_chain_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+class InvalidConfigurationProvider; end
+class ValidConfigurationProvider
+  def lookup(setting, *args); end
+end
+
+describe Configurate::LookupChain do
+  subject { described_class.new }
+  
+  describe "#add_provider" do
+    it "adds a valid provider" do
+      expect {
+        subject.add_provider ValidConfigurationProvider
+      }.to change { subject.instance_variable_get(:@provider).size }.by 1
+    end
+    
+    it "doesn't add an invalid provider" do
+      expect {
+        subject.add_provider InvalidConfigurationProvider
+      }.to raise_error ArgumentError
+    end
+    
+    it "passes extra args to the provider" do
+      ValidConfigurationProvider.should_receive(:new).with(:extra)
+      subject.add_provider ValidConfigurationProvider, :extra
+    end
+  end
+  
+  describe "#lookup" do
+    before do
+      subject.add_provider ValidConfigurationProvider
+      subject.add_provider ValidConfigurationProvider
+      @provider = subject.instance_variable_get(:@provider)
+    end
+    
+    it "it tries all providers" do
+      setting = Configurate::SettingPath.from_string "some.setting"
+      @provider.each do |provider|
+        provider.should_receive(:lookup).with(setting).and_raise(Configurate::SettingNotFoundError)
+      end
+      
+      subject.lookup(setting)
+    end
+    
+    it "stops if a value is found" do
+      @provider[0].should_receive(:lookup).and_return("something")
+      @provider[1].should_not_receive(:lookup)
+      subject.lookup("bla")
+    end
+    
+    it "converts numbers to strings" do
+      @provider[0].stub(:lookup).and_return(5)
+      subject.lookup("foo").should == "5"
+    end
+    
+    it "does not convert false to a string" do
+      @provider[0].stub(:lookup).and_return(false)
+      subject.lookup("enable").should be_false
+    end
+
+    it "converts 'true' to true" do
+      @provider[0].stub(:lookup).and_return("true")
+      subject.lookup("enable").should be_true
+    end
+
+    it "converts 'false' to false" do
+      @provider[0].stub(:lookup).and_return("false")
+      subject.lookup("enable").should be_false
+    end
+
+    it "returns the value unchanged if it can't be converted" do
+      value = mock
+      value.stub(:respond_to?).with(:to_s).and_return(false)
+      @provider[0].stub(:lookup).and_return(value)
+      subject.lookup("enable").should == value
+    end
+    
+    it "returns nil if no value is found" do
+      @provider.each { |p| p.stub(:lookup).and_raise(Configurate::SettingNotFoundError) }
+      subject.lookup("not.me").should be_nil
+    end
+  end
+end

data/spec/configurate/provider/dynamic_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Configurate::Provider::Dynamic do
+  subject { described_class.new }
+  describe "#lookup_path" do
+    it "returns nil if the setting was never set" do
+      subject.lookup_path(Configurate::SettingPath.new(["not_me"])).should be_nil
+    end
+    
+    it "remembers the setting if it ends with =" do
+      subject.lookup_path(Configurate::SettingPath.new(["find_me", "later="]), "there")
+      subject.lookup_path(Configurate::SettingPath.new(["find_me", "later"])).should == "there"
+    end
+    
+    it "calls .get on the argument if a proxy object is given" do
+      proxy = mock
+      proxy.stub(:respond_to?).and_return(true)
+      proxy.stub(:_proxy?).and_return(true)
+      proxy.should_receive(:get)
+      subject.lookup_path(Configurate::SettingPath.new(["bla="]), proxy)
+    end
+  end
+end

data/spec/configurate/provider/env_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Configurate::Provider::Env do
+  subject { described_class.new }
+  let(:existing_path) { ['existing', 'setting']}
+  let(:not_existing_path) { ['not', 'existing', 'path']}
+  let(:array_path) { ['array'] }
+  before(:all) do
+    ENV['EXISTING_SETTING'] = "there"
+    ENV['ARRAY'] = "foo,bar,baz"
+  end
+  
+  after(:all) do
+    ENV['EXISTING_SETTING'] = nil
+    ENV['ARRAY'] = nil
+  end
+  
+  describe '#lookup_path' do
+    it "joins and upcases the path" do
+      ENV.should_receive(:[]).with("EXISTING_SETTING")
+      subject.lookup_path(existing_path)
+    end
+    
+    it "returns nil if the setting isn't available" do
+      subject.lookup_path(not_existing_path).should be_nil
+    end
+    
+    it "makes an array out of comma separated values" do
+      subject.lookup_path(array_path).should == ["foo", "bar", "baz"]
+    end
+    
+    it "returns a unfrozen string" do
+      expect {
+        setting = subject.lookup_path(existing_path)
+        setting << "foo"
+      }.to_not raise_error
+    end
+  end
+end

data/spec/configurate/provider/yaml_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Configurate::Provider::YAML do
+  let(:settings) { {"toplevel" => "bar",
+                    "some" => { 
+                      "nested" => { "some" => "lala", "setting" => "foo"}
+                    }
+                   } }
+  
+  describe "#initialize" do
+    it "loads the file" do
+      file = "foobar.yml"
+      ::YAML.should_receive(:load_file).with(file).and_return({})
+      described_class.new file
+    end
+    
+    it "raises if the file is not found" do
+      ::YAML.stub(:load_file).and_raise(Errno::ENOENT)
+      expect {
+        described_class.new "foo"
+      }.to raise_error Errno::ENOENT
+    end
+      
+    
+    context "with a namespace" do
+      it "looks in the file for that namespace" do
+        namespace = "some"
+        ::YAML.stub(:load_file).and_return(settings)
+        provider = described_class.new 'bla', namespace: namespace
+        provider.instance_variable_get(:@settings).should == settings[namespace]
+      end
+      
+      it "raises if the namespace isn't found" do
+        ::YAML.stub(:load_file).and_return({})
+        expect {
+          described_class.new 'bla', namespace: "foo"
+        }.to raise_error ArgumentError
+      end
+    end
+    
+    context "with required set to false" do
+      it "doesn't raise if a file isn't found" do
+        ::YAML.stub(:load_file).and_raise(Errno::ENOENT)
+        expect {
+          described_class.new "not_me", required: false
+        }.not_to raise_error Errno::ENOENT
+      end
+      
+      it "doesn't raise if a namespace isn't found" do
+        ::YAML.stub(:load_file).and_return({})
+        expect {
+          described_class.new 'bla', namespace: "foo", required: false
+        }.not_to raise_error ArgumentError
+      end
+    end
+  end
+  
+  describe "#lookup_path" do
+    before do
+      ::YAML.stub(:load_file).and_return(settings)
+      @provider = described_class.new 'dummy'
+    end
+    
+    it "looks up the whole nesting" do
+      @provider.lookup_path(["some", "nested", "some"]).should == settings["some"]["nested"]["some"]
+    end
+    
+    it "returns nil if no setting is found" do
+      @provider.lookup_path(["not_me"]).should be_nil
+    end
+  end
+end

data/spec/configurate/provider_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Configurate::Provider::Base do
+  describe "#lookup" do
+    subject { described_class.new }
+    it "calls #lookup_path" do
+      path = Configurate::SettingPath.new(["foo", "bar"])
+      subject.should_receive(:lookup_path).with(path).and_return("something")
+      subject.lookup(path).should == "something"
+    end
+    
+    it "raises SettingNotFoundError if the #lookup_path returns nil" do
+      subject.stub(:lookup_path).and_return(nil)
+      expect {
+        subject.lookup("bla")
+      }.to raise_error Configurate::SettingNotFoundError
+    end
+  end
+end

data/spec/configurate/proxy_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+describe Configurate::Proxy do
+  let(:lookup_chain) { mock(lookup: "something") }
+  let(:proxy) { described_class.new(lookup_chain) }
+
+  describe "in case statements" do
+    it "acts like the target" do
+      pending "If anyone knows a way to overwrite ===, please tell me :P"
+      result = case proxy
+               when String
+                "string"
+               else
+                "wrong"
+               end
+      result.should == "string"
+    end
+  end
+  
+  describe "#method_missing" do
+    it "calls #target if the method ends with a ?" do
+      lookup_chain.should_receive(:lookup).and_return(false)
+      proxy.method_missing(:enable?)
+    end
+    
+    it "calls #target if the method ends with a =" do
+      lookup_chain.should_receive(:lookup).and_return(false)
+      proxy.method_missing(:url=)
+    end
+  end
+
+  describe "delegations" do
+    it "calls the target when negating" do
+      target = mock
+      lookup_chain.stub(:lookup).and_return(target)
+      target.should_receive(:!)
+      proxy.something.__send__(:!)
+    end
+
+    it "calls __send__ on send" do
+      proxy.should_receive(:__send__).with(:foo).and_return(nil)
+      proxy.send(:foo)
+    end
+  end
+
+  describe "#proxy" do
+    subject { proxy._proxy? }
+    it { should be_true }
+  end
+  
+  describe "#target" do
+    [:to_str, :to_s, :to_xml, :respond_to?, :present?, :!=,
+     :each, :try, :size, :length, :count, :==, :=~, :gsub, :blank?, :chop,
+     :start_with?, :end_with?].each do |method|
+      it "is called for accessing #{method} on the proxy" do
+        target = mock
+        lookup_chain.stub(:lookup).and_return(target)
+        target.stub(:respond_to?).and_return(true)
+        target.stub(:_proxy?).and_return(false)
+        target.should_receive(method).and_return("something")
+        proxy.something.__send__(method, mock)
+      end
+    end
+    
+    described_class::COMMON_KEY_NAMES.each do |method|
+      it "is not called for accessing #{method} on the proxy" do
+        target = mock
+        lookup_chain.should_not_receive(:lookup)
+        target.should_not_receive(method)
+        proxy.something.__send__(method, mock)
+      end
+    end
+    
+    it "returns nil if no setting is given" do
+      proxy.target.should be_nil
+    end
+  end
+end

data/spec/configurate/setting_path_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Configurate::SettingPath do
+  describe "::from_string" do
+    it "creates a path" do
+      described_class.from_string("foo.bar").should == described_class.new(["foo", "bar"])
+    end
+  end
+
+  describe "#is_setter?" do
+    context "with a setter signature as setting" do
+      subject { described_class.new([:foo=]).is_setter? } 
+      it { should be_true }
+    end
+
+    context "with a normal path as setting" do
+      subject { described_class.new([:foo]).is_setter? }
+      it { should be_false }
+    end
+  end
+
+
+  describe "#is_question_or_setter?" do
+    context "with a question signature as setting" do
+      subject { described_class.new([:foo?]).is_question_or_setter? }
+      it { should be_true }
+    end
+
+    context "with a setter signature as setting" do
+      subject { described_class.new([:foo=]).is_question_or_setter? } 
+      it { should be_true }
+    end
+
+    context "with a normal path as setting" do
+      subject { described_class.new([:foo]).is_question_or_setter? }
+      it { should be_false }
+    end
+  end
+
+  describe "#to_s" do
+    let(:path) { "example.path" }
+    subject { described_class.new(path.split(".")).to_s }
+    it { should == path }
+
+    context "with a question signature as setting" do
+      subject { described_class.new("#{path}?".split(".")).to_s }
+      it { should == path }
+    end
+  end
+
+  describe "#inspect" do
+    it "includes the dotted path" do
+      path = described_class.new([:foo, :bar])
+      path.inspect.should include "foo.bar"
+    end
+  end
+end

data/spec/configurate_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Configurate::Settings do
+  describe "#method_missing" do
+    subject { described_class.create }
+    
+    it "delegates the call to a new proxy object" do
+      proxy = mock
+      Configurate::Proxy.should_receive(:new).and_return(proxy)
+      proxy.should_receive(:method_missing).with(:some_setting).and_return("foo")
+      subject.some_setting
+    end
+  end
+  
+  [:lookup, :add_provider, :[]].each do |method|
+    describe "#{method}" do
+      subject { described_class.create }
+      
+      it "delegates the call to #lookup_chain" do
+        subject.lookup_chain.should_receive(method)
+        subject.send(method)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+
+begin
+  require 'coveralls'
+  Coveralls.wear!
+rescue; end
+
+require 'configurate'
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

metadata

@@ -1,16 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: configurate
 version: !ruby/object:Gem::Version
-  version: 0.0.2
-  prerelease: 
+  version: 0.0.3
 platform: ruby
 authors:
 - Jonne Haß
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-29 00:00:00.000000000 Z
-dependencies: []
+date: 2013-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 10.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.12.0
 description: Configurate is a flexible configuration system that can read settings
   from multiple sources at the same time.
 email: me@mrzyx.de
@@ -24,30 +51,49 @@ files:
 - lib/configurate/proxy.rb
 - lib/configurate/lookup_chain.rb
 - lib/configurate/provider.rb
+- lib/configurate/setting_path.rb
 - lib/configurate.rb
-homepage: https://github.com/MrZYX/configurate
+- spec/configurate/provider_spec.rb
+- spec/configurate/lookup_chain_spec.rb
+- spec/configurate/provider/yaml_spec.rb
+- spec/configurate/provider/env_spec.rb
+- spec/configurate/provider/dynamic_spec.rb
+- spec/configurate/setting_path_spec.rb
+- spec/configurate/proxy_spec.rb
+- spec/spec_helper.rb
+- spec/configurate_spec.rb
+homepage: http://mrzyx.github.com/configurate
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ~>
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Flexbile configuration system
-test_files: []
+test_files:
+- spec/configurate/provider_spec.rb
+- spec/configurate/lookup_chain_spec.rb
+- spec/configurate/provider/yaml_spec.rb
+- spec/configurate/provider/env_spec.rb
+- spec/configurate/provider/dynamic_spec.rb
+- spec/configurate/setting_path_spec.rb
+- spec/configurate/proxy_spec.rb
+- spec/spec_helper.rb
+- spec/configurate_spec.rb
+has_rdoc: 

metadata.gz.asc

@@ -0,0 +1,11 @@
+-----BEGIN PGP SIGNATURE-----
+Version: GnuPG v2.0.19 (GNU/Linux)
+
+iQEcBAABAgAGBQJRaxYFAAoJEPNH4OtHrHDW48EIAKYLXtBlFZNnezvqLJr7aQYt
+6HGva0USAoso1Rvn7t3HV4BIR7rFhscOUMMWwddHElNMnLxzsQU1vLQ0Zzk7+bGZ
+pR2irAuTjEJHZUCifVwSmIGK5CbyHbwqDhFOhexQOh8cPxYWo3IcHT/Pq7H3graS
+/POfxD1kUClc/l/NMV0OdCCXjdDisbVP+j2Ju6pNQU8QPk7QOjKDlmx7WTmlP3c7
+RA+gzCqxpYw2+F6XHCFoQRAdb8KYLOkn2YGUmGzcpbh19qniEMTVcum4YhWqvG+S
+3igR/0DX219J0332XhbqlcLzfcB+EeGHrRKlY1LGm8JeHA9MR6JNGpoROSPP2TY=
+=0vyr
+-----END PGP SIGNATURE-----