configliere 0.0.2 → 0.0.3

data/lib/configliere/define.rb

@@ -13,13 +13,15 @@ module Configliere
     #
     def define param, definitions={}
       self.param_definitions[param].merge! definitions
+      self.use(:environment) if definitions.include?(:encrypted)
+      self.use(:encrypted)   if definitions.include?(:encrypted)
       self[param] = definitions[:default] if definitions.include?(:default)
       self.environment_variables definitions[:environment], param if definitions.include?(:environment)
     end
 
     def param_definitions
       # initialize the param_definitions as an auto-vivifying hash if it's never been set
-      @param_definitions ||= Hash.new{|hsh, key| hsh[key] = {} }
+      @param_definitions ||= Sash.new{|hsh, key| hsh[key] = Sash.new  }
     end
 
     # performs type coercion
@@ -153,7 +155,23 @@ module Configliere
       end
       hsh
     end
-  public
+
+    # Pretend that any #define'd parameter is a method
+    #
+    # @example
+    #   Settings.define :foo
+    #   Settings.foo = 4
+    #   Settings.foo      #=> 4
+    def method_missing meth, *args
+      meth.to_s =~ /^(\w+)(=)?$/
+      name, setter = [$1, $2]
+      super unless name && param_definitions.include?(name)
+      if setter && (args.size == 1)
+        self[$1] = args.first
+      elsif (!setter) && args.empty?
+        self[meth]
+      else super ; end
+    end
   end
 
   Param.class_eval do

data/lib/configliere/encrypted.rb

@@ -32,7 +32,7 @@ module Configliere
     def export
       hsh = super()
       encrypted_params.each do |param|
-        val = hsh.deep_delete(*dotted_to_deep_keys(param)) or next
+        val = hsh.deep_delete(*convert_key(param)) or next
         hsh.deep_set( *(dotted_to_encrypted_keys(param) | [encrypted(val)]) )
       end
       hsh
@@ -50,7 +50,7 @@ module Configliere
     #    dotted_to_encrypted_keys('amazon.api.key')
     #    #=> [:amazon, :api, :encrypted_key]
     def dotted_to_encrypted_keys param
-      encrypted_path = dotted_to_deep_keys(param).dup
+      encrypted_path = convert_key(param).dup
       encrypted_path[-1] = "encrypted_#{encrypted_path.last}".to_sym
       encrypted_path
     end

data/lib/configliere/environment.rb

@@ -9,12 +9,12 @@ module Configliere
       envs.each do |env|
         case env
         when Hash
-          env.each do |env, param|
-            adopt_environment_variable! env.to_s, param
+          env.each do |param, env|
+            adopt_environment_variable! param, env
           end
         else
           param = env.to_s.downcase.to_sym
-          adopt_environment_variable! env.to_s, param
+          adopt_environment_variable! param, env
         end
       end
     end
@@ -24,7 +24,8 @@ module Configliere
     end
 
   protected
-    def adopt_environment_variable! env, param
+    def adopt_environment_variable! param, env
+      env   = env.to_s
       param_definitions[param][:environment] ||= env
       val = ENV[env]
       self[param] = val if val

data/lib/configliere/param.rb

@@ -1,22 +1,48 @@
+require 'configliere/core_ext/sash.rb'
 module Configliere
+  class ParamParent < ::Hash
+    def finally *args, &block
+      nil #no-op
+    end
+    # default export method: self
+    def export
+      to_hash
+    end
+    # terminate resolution chain
+    def resolve!
+    end
+
+    def validate!
+      true
+    end
+  end
+
   #
   # Hash of fields to store.
   #
   # Any field name beginning with 'decrypted_' automatically creates a
   # counterpart 'encrypted_' field using the encrypt_pass.
   #
-  class Param < ::Hash
+  class Param < Configliere::ParamParent
 
-    # Initialize with the encrypt_pass and the initial contents of the hash.
+    # @param constructor<Object>
+    #   The default value for the mash. Defaults to an empty hash.
     #
-    # @example
-    #   # Create a param for a hypothetical database with encrypt_pass "your_mom"
-    #   Configliere::Param.new 'your_mom',
-    #     :username=>"mysql_username", :decrypted_password=>"mysql_password"
-    #
-    def initialize hsh={}
-      super()
-      merge! hsh
+    # @details [Alternatives]
+    #   If constructor is a Hash, a new mash will be created based on the keys of
+    #   the hash and no default value will be set.
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor) unless constructor.empty?
+      else
+        super(constructor)
+      end
+    end
+
+    # @return [Hash] The mash as a Hash with string keys.
+    def to_hash
+      Hash.new(default).merge(self)
     end
 
     #
@@ -47,53 +73,50 @@ module Configliere
 
     def []= param, val
       if param =~ /\./
-        return deep_set( *( dotted_to_deep_keys(param) | [val] ))
+        return deep_set( *(convert_key(param) | [val]) )
       else
-        super param.to_sym, val
+        super param, val
       end
     end
 
     def [] param
       if param =~ /\./
-        return deep_get( *dotted_to_deep_keys(param) )
+        return deep_get( *convert_key(param) )
       else
-        super param.to_sym
+        super param
       end
     end
 
     def delete param
       if param =~ /\./
-        return deep_delete( *dotted_to_deep_keys(param) )
+        return deep_delete( *convert_key(param) )
       else
-        super param.to_sym
+        super param
       end
     end
 
-    # returns an actual Hash, not a Param < Hash
-    def to_hash
-      {}.merge! self
-    end
-
     def use *args
       hsh = args.pop if args.last.is_a?(Hash)
       Configliere.use *args
-      defaults(hsh) unless hsh.nil?
+      self.deep_merge!(hsh) unless hsh.nil?
     end
 
+    # see Configliere::ConfigBlock#finally
+    def finally *args, &block
+      use :config_block
+      super
+    end
   protected
-    # turns a dotted param ('moon.cheese.type') into
-    # an array of sequential keys for deep_set and deep_get
-    def dotted_to_deep_keys dotted
-      dotted.to_s.split(".").map{|key| key.to_sym}
+    # @param key<Object> The key to convert.
+    #
+    # @param [Object]
+    #   The converted key. A dotted param ('moon.cheese.type') becomes
+    #   an array of sequential keys for deep_set and deep_get
+    #
+    # @api private
+    def convert_key dotted
+      dotted.to_s.split(".").map{|key| key.to_sym }
     end
 
-    # simple (no-arg) method_missing callse
-    def method_missing meth, *args
-      if args.empty? && meth.to_s =~ /^\w+$/
-        self[meth]
-      elsif args.size == 1 && meth.to_s =~ /^(\w+)=$/
-        self[$1] = args.first
-      else super(meth, *args) end
-    end
   end
 end

data/spec/configliere/config_file_spec.rb

@@ -4,6 +4,7 @@ Configliere.use :config_file
 describe "Configliere::ConfigFile" do
   before do
     @config = Configliere.new :my_param => 'val'
+    FileUtils.stub! :mkdir_p
   end
 
   describe 'loads a config file' do
@@ -50,6 +51,12 @@ describe "Configliere::ConfigFile" do
         fake_file.should_receive(:<<).with("--- \n:my_param: val\n")
         @config.save! '/fake/path.yaml'
       end
+      it 'ensures the directory exists' do
+        fake_file = StringIO.new('', 'w')
+        File.stub!(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
+        FileUtils.should_receive(:mkdir_p).with('/fake')
+        @config.save! '/fake/path.yaml'
+      end
     end
   end
 

data/spec/configliere/core_ext/hash_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+describe Hash do
+  before(:each) do
+    @hash = { :hsh1a => { :hsh2 => { :key3 => "val3" }, :key2 => "val2" }, :key1b => 'val1b' }
+  end
+
+  describe "#deep_merge!" do
+    it "merges two subhashes when they share a key" do
+      @hash.deep_merge!(:hsh1a => { :hsh2 => { :key3a => "val3a" } })
+      @hash.should == { :hsh1a => { :hsh2 => { :key3a => "val3a", :key3 => "val3" }, :key2 => "val2" }, :key1b => 'val1b' }
+    end
+    it "preserves values in the original" do
+      @hash.deep_merge! :other_key => "other_val"
+      @hash[:hsh1a][:key2].should == "val2"
+      @hash[:other_key].should == "other_val"
+    end
+    it "replaces values from the given Hash" do
+      @hash.deep_merge!(:hsh1a => { :hsh2 => { :key3 => "new_val3" }, :key2 => { "other2" => "other_val2" }})
+      @hash[:hsh1a][:hsh2][:key3].should == 'new_val3'
+      @hash[:hsh1a][:key2].should == { "other2" => "other_val2" }
+    end
+  end
+
+
+  describe "#deep_set" do
+    it 'should set a new value (single arg)' do
+      @hash.deep_set :new_key, 'new_val'
+      @hash[:new_key].should == 'new_val'
+    end
+    it 'should set a new value (multiple args)' do
+      @hash.deep_set :hsh1a, :hsh2, :new_key, 'new_val'
+      @hash[:hsh1a][:hsh2][:new_key].should == 'new_val'
+    end
+    it 'should replace an existing value (single arg)' do
+      @hash.deep_set :key1b, 'new_val'
+      @hash[:key1b].should == 'new_val'
+    end
+    it 'should replace an existing value (multiple args)' do
+      @hash.deep_set :hsh1a, :hsh2, 'new_val'
+      @hash[:hsh1a][:hsh2].should == 'new_val'
+    end
+    it 'should auto-vivify intermediate hashes' do
+      @hash.deep_set :one, :two, :three, :four, 'new_val'
+      @hash[:one][:two][:three][:four].should == 'new_val'
+    end
+  end
+
+  describe "#deep_delete" do
+    it 'should remove the key from the array (multiple args)' do
+      @hash.deep_delete(:hsh1a)
+      @hash[:hsh1a].should be_nil
+      @hash.should == { :key1b => 'val1b'}
+    end
+    it 'should remove the key from the array (multiple args)' do
+      @hash.deep_delete(:hsh1a, :hsh2, :key3)
+      @hash[:hsh1a][:hsh2][:key3].should be_nil
+      @hash.should == {:key1b=>"val1b", :hsh1a=>{:key2=>"val2", :hsh2=>{}}}
+    end
+    it 'should return the value if present (single args)' do
+      returned_val = @hash.deep_delete(:key1b)
+      returned_val.should == 'val1b'
+    end
+    it 'should return the value if present (multiple args)' do
+      returned_val = @hash.deep_delete(:hsh1a, :hsh2, :key3)
+      returned_val.should == 'val3'
+    end
+    it 'should return nil if the key is absent (single arg)' do
+      returned_val = @hash.deep_delete(:hsh1a, :hsh2, :missing_key)
+      returned_val.should be_nil
+    end
+    it 'should return nil if the key is absent (multiple args)' do
+      returned_val = @hash.deep_delete(:missing_key)
+      returned_val.should be_nil
+    end
+  end
+
+end

data/spec/configliere/core_ext/sash_spec.rb

@@ -0,0 +1,313 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '../../spec_helper'))
+
+class AwesomeHash < Hash
+end
+
+describe Sash do
+  before(:each) do
+    @hash = { "str_key" => "strk_val", :sym_key => "symk_val" }
+    @sub  = AwesomeHash.new("str_key" => "strk_val", :sym_key => "symk_val")
+  end
+
+
+  describe "#deep_merge!" do
+    before do
+      @sash = Sash.new :hsh1 => { :hsh2 => { :key3 => "val3" }, :key2 => "val2" }
+    end
+    it "merges two subhashes when they share a key" do
+      @sash.deep_merge!(:hsh1 => { :hsh2 => { :key3a => "val3a" } })
+      @sash.should == { :hsh1 => { :hsh2 => { :key3a => "val3a", :key3 => "val3" }, :key2 => "val2" } }
+    end
+    it "merges two subhashes when they share a symbolized key" do
+      @sash.deep_merge!(:hsh1 => { "hsh2" => { "key3a" => "val3a" } })
+      @sash.should == { :hsh1 => { :hsh2  => { :key3a  => "val3a", :key3 => "val3" }, :key2 => "val2" } }
+    end
+    it "preserves values in the original" do
+      @sash.deep_merge! :other_key => "other_val"
+      @sash[:other_key].should == "other_val"
+      @sash[:hsh1][:key2].should == "val2"
+    end
+
+    it "converts all keys into symbols when param is a Hash"  do
+      @sash.deep_merge!(:hsh1 => { "hsh2" => { "key3a" => "val3a" } })
+      @sash.should == { :hsh1 => { :hsh2 => { :key3a => "val3a", :key3 => "val3" }, :key2 => "val2" } }
+    end
+    it "converts all Hash values into Sashes if param is a Hash"  do
+      @sash.deep_merge!({:hsh1 => { :hsh2 => { :key3a => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      @sash[:hsh1].should be_an_instance_of(Sash)
+      @sash[:hsh1][:hsh2].should be_an_instance_of(Sash)
+      @sash[:other1].should be_an_instance_of(Sash)
+    end
+    it "replaces values from the given Hash" do
+      @sash.deep_merge!(:hsh1 => { :hsh2 => { :key3 => "new_val3" }, :key2 => { "other2" => "other_val2" }})
+      @sash[:hsh1][:hsh2][:key3].should == 'new_val3'
+      @sash[:hsh1][:key2].should == { :other2 => "other_val2" }
+    end
+  end
+
+  describe "#initialize" do
+    it 'converts all keys into symbols when param is a Hash' do
+      sash = Sash.new(@hash)
+      sash.keys.any? { |key| key.is_a?(String) }.should be_false
+    end
+
+    it 'converts all pure Hash values into Sashes if param is a Hash' do
+      sash = Sash.new :sym_key => @hash
+
+      sash[:sym_key].should be_an_instance_of(Sash)
+      # sanity check
+      sash[:sym_key][:sym_key].should == "symk_val"
+    end
+
+    it 'doesn not convert Hash subclass values into Sashes' do
+      sash = Sash.new :sub => @sub
+      sash[:sub].should be_an_instance_of(AwesomeHash)
+    end
+
+    it 'converts all value items if value is an Array' do
+      sash = Sash.new :arry => { :sym_key => [@hash] }
+
+      sash[:arry].should be_an_instance_of(Sash)
+      # sanity check
+      sash[:arry][:sym_key].first[:sym_key].should == "symk_val"
+
+    end
+
+    it 'delegates to superclass constructor if param is not a Hash' do
+      sash = Sash.new("dash berlin")
+
+      sash["unexisting key"].should == "dash berlin"
+    end
+  end # describe "#initialize"
+
+
+
+  describe "#update" do
+    it 'converts all keys into symbols when param is a Hash' do
+      sash = Sash.new(@hash)
+      sash.update("starry" => "night")
+
+      sash.keys.any?{|key| key.is_a?(String) }.should be_false
+    end
+
+    it 'converts all Hash values into Sashes if param is a Hash' do
+      sash = Sash.new :hash => @hash
+      sash.update(:hash => { :sym_key => "is buggy in Ruby 1.8.6" })
+
+      sash[:hash].should be_an_instance_of(Sash)
+    end
+  end # describe "#update"
+
+
+
+  describe "#[]=" do
+    it 'converts key into symbol' do
+      sash = Sash.new(@hash)
+      sash["str_key"] = { "starry" => "night" }
+
+      sash.keys.any?{|key| key.is_a?(String) }.should be_false
+    end
+
+    it 'converts all Hash value into Sash' do
+      sash = Sash.new :hash => @hash
+      sash[:hash] = { :sym_key => "is buggy in Ruby 1.8.6" }
+
+      sash[:hash].should be_an_instance_of(Sash)
+    end
+  end # describe "#[]="
+
+
+
+  describe "#key?" do
+    before(:each) do
+      @sash = Sash.new(@hash)
+    end
+
+    it 'converts key before lookup' do
+      @sash.key?("str_key").should be_true
+      @sash.key?(:str_key).should be_true
+
+      @sash.key?("sym_key").should be_true
+      @sash.key?(:sym_key).should be_true
+
+      @sash.key?(:rainclouds).should be_false
+      @sash.key?("rainclouds").should be_false
+    end
+
+    it 'is aliased as include?' do
+      @sash.include?("str_key").should be_true
+      @sash.include?(:str_key).should be_true
+
+      @sash.include?("sym_key").should be_true
+      @sash.include?(:sym_key).should be_true
+
+      @sash.include?(:rainclouds).should be_false
+      @sash.include?("rainclouds").should be_false
+    end
+
+    it 'is aliased as member?' do
+      @sash.member?("str_key").should be_true
+      @sash.member?(:str_key).should be_true
+
+      @sash.member?("sym_key").should be_true
+      @sash.member?(:sym_key).should be_true
+
+      @sash.member?(:rainclouds).should be_false
+      @sash.member?("rainclouds").should be_false
+    end
+  end # describe "#key?"
+
+  def arrays_should_be_equal arr1, arr2
+    arr1.sort_by{|s| s.to_s }.should == arr2.sort_by{|s| s.to_s }
+  end
+
+  describe "#dup" do
+    it 'returns instance of Sash' do
+      Sash.new(@hash).dup.should be_an_instance_of(Sash)
+    end
+
+    it 'preserves keys' do
+      sash = Sash.new(@hash)
+      dup  = sash.dup
+
+      arrays_should_be_equal sash.keys, dup.keys
+    end
+
+    it 'preserves value' do
+      sash = Sash.new(@hash)
+      dup  = sash.dup
+
+      arrays_should_be_equal sash.values, dup.values
+    end
+  end
+
+
+
+  describe "#to_hash" do
+    it 'returns instance of Hash' do
+      Sash.new(@hash).to_hash.should be_an_instance_of(Hash)
+    end
+
+    it 'preserves keys' do
+      sash = Sash.new(@hash)
+      converted  = sash.to_hash
+      arrays_should_be_equal sash.keys, converted.keys
+    end
+
+    it 'preserves value' do
+      sash = Sash.new(@hash)
+      converted = sash.to_hash
+      arrays_should_be_equal sash.values, converted.values
+    end
+  end
+
+
+
+  describe "#stringify_keys" do
+    it 'returns instance of Sash' do
+      Sash.new(@hash).stringify_keys.should be_an_instance_of(Hash)
+    end
+
+    it 'converts keys to symbols' do
+      sash = Sash.new(@hash)
+      converted  = sash.stringify_keys
+
+      converted_keys = converted.keys.sort{|k1, k2| k1.to_s <=> k2.to_s}
+      orig_keys = sash.keys.map{|k| k.to_sym}.sort{|i1, i2| i1.to_s <=> i2.to_s}
+
+      converted_keys.should == orig_keys
+    end
+
+    it 'preserves value' do
+      sash = Sash.new(@hash)
+      converted = sash.stringify_keys
+
+      arrays_should_be_equal sash.values, converted.values
+    end
+  end
+
+
+
+  describe "#delete" do
+    it 'converts Symbol key into String before deleting' do
+      sash = Sash.new(@hash)
+
+      sash.delete(:sym_key)
+      sash.key?("hash").should be_false
+    end
+
+    it 'works with String keys as well' do
+      sash = Sash.new(@hash)
+
+      sash.delete("str_key")
+      sash.key?("str_key").should be_false
+    end
+  end
+
+
+
+  describe "#merge" do
+    before(:each) do
+      @sash = Sash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'returns instance of Sash' do
+      @sash.should be_an_instance_of(Sash)
+    end
+
+    it 'merges in give Hash' do
+      @sash["no"].should == "in between"
+    end
+  end
+
+
+
+  describe "#fetch" do
+    before(:each) do
+      @sash = Sash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'converts key before fetching' do
+      @sash.fetch("no").should == "in between"
+    end
+
+    it 'returns alternative value if key lookup fails' do
+      @sash.fetch("flying", "screwdriver").should == "screwdriver"
+    end
+  end
+
+
+  describe "#default" do
+    before(:each) do
+      @sash = Sash.new(:yet_another_technical_revolution)
+    end
+
+    it 'returns default value unless key exists in sash' do
+      @sash.default("peak oil is now behind, baby").should == :yet_another_technical_revolution
+    end
+
+    it 'returns existing value if key is String and exists in sash' do
+      @sash.update("no" => "in between")
+      @sash.default("no").should == "in between"
+    end
+  end
+
+
+  describe "#values_at" do
+    before(:each) do
+      @sash = Sash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'is indifferent to whether keys are strings or symbols' do
+      @sash.values_at("sym_key", :str_key, :no).should == ["symk_val", "strk_val", "in between"]
+    end
+  end
+
+
+  describe "#symbolize_keys!" do
+    it 'returns the sash itself' do
+      sash = Sash.new(@hash)
+      sash.symbolize_keys!.object_id.should == sash.object_id
+    end
+  end
+end