configliere 0.4.5 → 0.4.6

data/FEATURES.txt

@@ -1,3 +1,4 @@
+
 Configliere::Commandline
   with long-format argvs
     accepts --param=val pairs
@@ -26,6 +27,8 @@ Configliere::Commandline
     exports dashed flags
   #resolve!
     calls super and returns self
+  #validate!
+    calls super and returns self
 
 Configliere::Commands
   when no commands are defined
@@ -45,13 +48,16 @@ Configliere::Commands
     displays the commands and their descriptions
   #resolve!
     calls super and returns self
+  #validate!
+    calls super and returns self
 
 Configliere::ConfigBlock
   resolving
     runs blocks
     resolves blocks last
-    #resolve!
-      calls super and returns self
+    calls super and returns self
+  #validate!
+    calls super and returns self
 
 Configliere::ConfigFile
   is used by default
@@ -62,24 +68,29 @@ Configliere::ConfigFile
       with an absolute pathname uses it directly
       with a simple filename, references it to the default config dir
       returns the config object for chaining
+  #read_yaml
+    loads yaml
     with an environment scope
       slices out a subhash given by :env
       slices out a different subhash with a different :env
       does no slicing without the :env option
       has no effect if the key given by :env option is absent
-      does not type convert the :env option
+      lets you use a string if the loading hash has a string
   saves to a config file
     with an absolute pathname, as given
     with a simple pathname, in the default config dir
     and ensures the directory exists
   #resolve!
     calls super and returns self
+  #validate!
+    calls super and returns self
 
 Crypter
   encrypts
   decrypts
 
 DeepHash
+  responds to #symbolize_keys, #symbolize_keys! and #stringify_keys but not #stringify_keys!
   #initialize
     adopts a Hash when given
     converts all pure Hash values into DeepHashes if param is a Hash
@@ -120,32 +131,58 @@ DeepHash
     gets values for all given keys even if missing
     is OK when empty
     returns an instance of the same class
-  assert_valid_keys
-    is true and does not raise when valid
-    fails when invalid
   #delete
     converts Symbol key into String before deleting
     works with String keys as well
-  #merge
-    returns instance of DeepHash
-    merges in give Hash
   #fetch
     converts key before fetching
     returns alternative value if key lookup fails
   #values_at
     is indifferent to whether keys are strings or symbols
   #symbolize_keys
-    with bang returns the deep_hash itself
     returns a dup of itself
+  #symbolize_keys!
+    with bang returns the deep_hash itself
+  #stringify_keys
+    converts keys that are all symbols
+    returns a Hash, not a DeepHash
+    only stringifies and hashifies the top level
+  #assert_valid_keys
+    is true and does not raise when valid
+    fails when invalid
+  #merge
+    merges given Hash
+    returns a new instance
+    returns instance of DeepHash
+    converts all Hash values into DeepHashes
+    converts string keys to symbol keys even if they occur deep in the given hash
+    DOES merge values where given hash has nil value
+    replaces child hashes, and does not merge them
+  #merge!
+    merges given Hash
+    returns a new instance
+    returns instance of DeepHash
+    converts all Hash values into DeepHashes
+    converts string keys to symbol keys even if they occur deep in the given hash
+    DOES merge values where given hash has nil value
+    replaces child hashes, and does not merge them
   #reverse_merge
-    merges defaults into options, creating a new hash
-    with bang merges! defaults into options, replacing options
+    merges given Hash
+    returns a new instance
+    returns instance of DeepHash
+    converts all Hash values into DeepHashes
+    converts string keys to symbol keys even if they occur deep in the given hash
+    DOES merge values where given hash has nil value
+    replaces child hashes, and does not merge them
   #deep_merge!
     merges two subhashes when they share a key
     merges two subhashes when they share a symbolized key
     preserves values in the original
-    replaces values from the given DeepHash
-    replaces values from the given DeepHash
+    converts all Hash values into DeepHashes
+    converts string keys to symbol keys even if they occur deep in the given hash
+    replaces values from the given hash
+    replaces arrays and does not append to them
+    does not replaces values where given hash has nil value
   #deep_set
     should set a new value (single arg)
     should set a new value (multiple args)
@@ -164,6 +201,7 @@ Configliere::Define
   takes a description
   defining any aspect of a param
     adopts values
+    returns self
     merges new definitions
     lists params defined as the given aspect
   definition_of
@@ -237,6 +275,8 @@ Configliere::Define
     type converts
   #resolve!
     calls super and returns self
+  #validate!
+    calls super and returns self
 
 Configliere::Encrypted
   defines encrypted params
@@ -257,6 +297,8 @@ Configliere::Encrypted
   #resolve!
     calls super and returns self
     removes the encrypt_pass from sight
+  #validate!
+    calls super and returns self
 
 Configliere::EnvVar
   environment variables can be defined
@@ -265,6 +307,8 @@ Configliere::EnvVar
     with #define
   #resolve!
     calls super and returns self
+  #validate!
+    calls super and returns self
 
 Configliere::Param
   calling #defaults
@@ -294,5 +338,5 @@ Configliere
   creates a global method Settings, so you can say Settings(:foo => :bar)
   requires corresponding plugins when you call use
 
-Finished in 0.26971 seconds
-214 examples, 0 failures
+Finished in 0.61948 seconds
+247 examples, 0 failures

data/VERSION

@@ -1 +1 @@
-0.4.5
+0.4.6

data/configliere.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{configliere}
-  s.version = "0.4.5"
+  s.version = "0.4.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["infochimps", "mrflip"]
-  s.date = %q{2011-05-18}
+  s.date = %q{2011-05-21}
   s.description = %q{ You've got a script. It's got some settings. Some settings are for this module, some are for that module. Most of them don't change. Except on your laptop, where the paths are different.  Or when you're in production mode. Or when you're testing from the command line.
 
    "" So, Consigliere of mine, I think you should tell your Don what everyone knows. "" -- Don Corleone

data/lib/configliere/config_file.rb

@@ -30,11 +30,15 @@ module Configliere
       if filename.is_a?(Symbol) then raise Configliere::DeprecatedError, "Loading from a default config file is no longer provided" ; end
       filename = expand_filename(filename)
       begin
-        new_data = YAML.load(File.open(filename)) || {}
+        read_yaml(File.open(filename), options)
       rescue Errno::ENOENT => e
         warn "Loading empty configliere settings file #{filename}"
-        new_data = {}
       end
+      self
+    end
+
+    def read_yaml yaml_str, options={}
+      new_data = YAML.load(yaml_str) || {}
       # Extract the :env (production/development/etc)
       if options[:env]
         new_data = new_data[options[:env]] || {}

data/lib/configliere/deep_hash.rb

@@ -73,8 +73,6 @@ class DeepHash < Hash
     self.dup.update(hash, &block)
   end
 
-  alias_method :merge!, :update
-
   # @param other_hash<Hash>
   #   A hash to update values in the deep_hash with. The keys and the values will be
   #   converted to DeepHash format.
@@ -89,17 +87,58 @@ class DeepHash < Hash
     regular_update(deep_hash, &block)
   end
 
-  # Return a new hash with all keys converted to symbols, as long as
-  # they respond to +to_sym+.
+  alias_method :merge!, :update
+
+  # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
+  # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
+  #
+  #   def setup(options = {})
+  #     options.reverse_merge! :size => 25, :velocity => 10
+  #   end
+  #
+  # Using <tt>merge</tt>, the above example would look as follows:
+  #
+  #   def setup(options = {})
+  #     { :size => 25, :velocity => 10 }.merge(options)
+  #   end
+  #
+  # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
+  # have the respective key.
+  def reverse_merge(other_hash)
+    self.class.new(other_hash).merge!(self)
+  end unless method_defined?(:reverse_merge)
+
+  # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
+  # Modifies the receiver in place.
+  def reverse_merge!(other_hash)
+    merge!( other_hash ){|k,o,n| convert_value(o) }
+  end unless method_defined?(:reverse_merge!)
+
+  # This DeepHash with all its keys converted to symbols, as long as they
+  # respond to +to_sym+. (this is always true for a deep_hash)
+  #
+  # @return [DeepHash] A copy of this deep_hash.
   def symbolize_keys
     dup.symbolize_keys!
   end unless method_defined?(:symbolize_keys)
 
-  # Used to provide the same interface as Hash.
+  # This DeepHash with all its keys converted to symbols, as long as they
+  # respond to +to_sym+. (this is always true for a deep_hash)
   #
   # @return [DeepHash] This deep_hash unchanged.
   def symbolize_keys!; self end
 
+  # Return a new hash with all top-level keys converted to strings.
+  #
+  # @return [Hash]
+  def stringify_keys
+    hsh = Hash.new(default)
+    self.each do |key, val|
+      hsh[key.to_s] = val
+    end
+    hsh
+  end
+
   #
   # remove all key-value pairs where the value is nil
   #
@@ -112,6 +151,7 @@ class DeepHash < Hash
   def compact!
     replace(compact)
   end
+
   # Slice a hash to include only the given keys. This is useful for
   # limiting an options hash to valid keys before passing to a method:
   #
@@ -163,31 +203,6 @@ class DeepHash < Hash
     result
   end unless method_defined?(:extract!)
 
-  # Allows for reverse merging two hashes where the keys in the calling hash take precedence over those
-  # in the <tt>other_hash</tt>. This is particularly useful for initializing an option hash with default values:
-  #
-  #   def setup(options = {})
-  #     options.reverse_merge! :size => 25, :velocity => 10
-  #   end
-  #
-  # Using <tt>merge</tt>, the above example would look as follows:
-  #
-  #   def setup(options = {})
-  #     { :size => 25, :velocity => 10 }.merge(options)
-  #   end
-  #
-  # The default <tt>:size</tt> and <tt>:velocity</tt> are only set if the +options+ hash passed in doesn't already
-  # have the respective key.
-  def reverse_merge(other_hash)
-    other_hash.merge(self)
-  end unless method_defined?(:reverse_merge)
-
-  # Performs the opposite of <tt>merge</tt>, with the keys and values from the first hash taking precedence over the second.
-  # Modifies the receiver in place.
-  def reverse_merge!(other_hash)
-    merge!( other_hash ){|k,o,n| o }
-  end unless method_defined?(:reverse_merge!)
-
   # Validate all keys in a hash match *valid keys, raising ArgumentError on a mismatch.
   # Note that keys are NOT treated indifferently, meaning if you use strings for keys but assert symbols
   # as keys, this will fail.

data/spec/configliere/config_file_spec.rb

@@ -45,57 +45,62 @@ describe Configliere::ConfigFile do
       @config.should_receive(:warn).with("Loading empty configliere settings file #{Configliere::DEFAULT_CONFIG_DIR}/nonexistent_file.yaml")
       @config.read('nonexistent_file.yaml').should == {}
     end
+  end
 
+  describe '#read_yaml' do
+    before do
+      @config.merge! :reload => :whatever
+      @simple_yaml       = { :my_param => 'override_val', 'also_a_param' => true, 'strkey' => 'val', :falsekey => false, :nilkey => nil }.to_yaml
+      @yaml_with_subenvs = { :development => { :reload => true }, :production => { :reload => false }}.to_yaml
+    end
 
-    describe 'with an environment scope' do
-      before do
-        @config.defaults :reload => :unset
-        @hash_with_subenvs = { :development => { :reload => true }, :production => { :reload => false }}
-        File.stub :open
-        YAML.should_receive(:load).and_return(@hash_with_subenvs)
-      end
+    it 'loads yaml' do
+      @config.read_yaml(@simple_yaml)
+      @config.should     == { :reload => :whatever, :my_param => 'override_val', :also_a_param  => true, :strkey  => 'val', :falsekey => false, :nilkey => nil }
+      @config.should_not == { :reload => :whatever, :my_param => 'override_val', 'also_a_param' => true, 'strkey' => 'val', :falsekey => false, :nilkey => nil }
+    end
 
+    describe 'with an environment scope' do
       it 'slices out a subhash given by :env' do
-        @config.read('f', :env => :development)
+        @config.read_yaml(@yaml_with_subenvs, :env => :development)
         @config.should == { :reload => true, :my_param => 'default_val', :also_a_param => true }
       end
 
       it 'slices out a different subhash with a different :env' do
-        @config.read('f', :env => :production)
+        @config.read_yaml(@yaml_with_subenvs, :env => :production)
         @config.should == { :reload => false, :my_param => 'default_val', :also_a_param => true }
       end
 
       it 'does no slicing without the :env option' do
-        @config.read('f')
-        @config.should == { :development => { :reload => true }, :production => { :reload => false }, :reload => :unset, :my_param => 'default_val', :also_a_param => true }
+        @config.read_yaml(@yaml_with_subenvs)
+        @config.should == { :development => { :reload => true }, :production => { :reload => false }, :reload => :whatever, :my_param => 'default_val', :also_a_param => true }
       end
 
       it 'has no effect if the key given by :env option is absent' do
-        @config.read('f', :env => :foobar)
-        @config.should == { :reload => :unset, :my_param => 'default_val', :also_a_param => true }
+        @config.read_yaml(@yaml_with_subenvs, :env => :foobar)
+        @config.should == { :reload => :whatever, :my_param => 'default_val', :also_a_param => true }
       end
 
-      it 'does not type convert the :env option' do
-        @hash_with_subenvs['john_woo'] = { :reload => :sideways }
-        @config.read('f', :env => 'john_woo')
+      it 'lets you use a string if the loading hash has a string' do
+        yaml_with_string_subenv = { 'john_woo' => { :reload => :sideways }}.to_yaml
+        @config.read_yaml(yaml_with_string_subenv, :env => 'john_woo')
         @config.should == { :reload => :sideways, :my_param => 'default_val', :also_a_param => true }
       end
     end
   end
 
-
   describe 'saves to a config file' do
     it 'with an absolute pathname, as given' do
       fake_file = StringIO.new('', 'w')
       File.should_receive(:open).with(%r{/fake/path.yaml}, 'w').and_yield(fake_file)
-      fake_file.should_receive(:<<).with("--- \n:my_param: default_val\n:also_a_param: true\n")
+      fake_file.should_receive(:<<).with({ :my_param => 'default_val', :also_a_param => true }.to_yaml)
       @config.save! '/fake/path.yaml'
     end
 
     it 'with a simple pathname, in the default config dir' do
       fake_file = StringIO.new('', 'w')
       File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_DIR + '/file.yaml', 'w').and_yield(fake_file)
-      fake_file.should_receive(:<<).with("--- \n:my_param: default_val\n:also_a_param: true\n")
+      fake_file.should_receive(:<<).with({ :my_param => 'default_val', :also_a_param => true }.to_yaml)
       @config.save! 'file.yaml'
     end
 

data/spec/configliere/deep_hash_spec.rb

@@ -4,7 +4,7 @@ class AwesomeHash < DeepHash ; end
 
 describe DeepHash do
   before(:each) do
-    @deep_hash = DeepHash.new.merge!({ :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => 'val1b' })
+    @deep_hash = DeepHash.new({ :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b' })
     @hash = { "str_key" => "strk_val", :sym_key => "symk_val"}
     @sub  = AwesomeHash.new("str_key" => "strk_val", :sym_key => "symk_val")
   end
@@ -62,7 +62,7 @@ describe DeepHash do
     it 'symbolizes keys' do
       @deep_hash['leaf_at_top'] = :fedora
       @deep_hash['new']         = :unseen
-      @deep_hash.should == {:nested_1 => {:nested_2 => {:leaf_3 => "val3"}, :leaf_2 => "val2"}, :leaf_at_top => :fedora, :new => :unseen}
+      @deep_hash.should == {:nested_1 => {:nested_2 => {:leaf_3 => "val3"}, :leaf_2 => ['arr']}, :leaf_at_top => :fedora, :new => :unseen}
     end
     it 'deep-sets dotted vals, replacing values' do
       @deep_hash['moon.man'] = :cheesy
@@ -211,23 +211,6 @@ describe DeepHash do
     end
   end
 
-  describe 'assert_valid_keys' do
-    before do
-      @deep_hash = DeepHash.new({ :failure => "stuff", :funny => "business" })
-    end
-
-    it 'is true and does not raise when valid' do
-      @deep_hash.assert_valid_keys([ :failure, :funny ]).should be_nil
-      @deep_hash.assert_valid_keys(:failure, :funny).should be_nil
-    end
-
-    it 'fails when invalid' do
-      @deep_hash[:failore] = @deep_hash.delete(:failure)
-      lambda{ @deep_hash.assert_valid_keys([ :failure, :funny ]) }.should raise_error(ArgumentError, "Unknown key(s): failore")
-      lambda{ @deep_hash.assert_valid_keys(:failure, :funny)     }.should raise_error(ArgumentError, "Unknown key(s): failore")
-    end
-  end
-
   describe "#delete" do
     it 'converts Symbol key into String before deleting' do
       deep_hash = DeepHash.new(@hash)
@@ -244,23 +227,9 @@ describe DeepHash do
     end
   end
 
-  describe "#merge" do
-    before(:each) do
-      @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
-    end
-
-    it 'returns instance of DeepHash' do
-      @deep_hash.should be_an_instance_of(DeepHash)
-    end
-
-    it 'merges in give Hash' do
-      @deep_hash["no"].should == "in between"
-    end
-  end
-
   describe "#fetch" do
     before(:each) do
-      @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
+      @deep_hash = DeepHash.new(:no => "in between")
     end
 
     it 'converts key before fetching' do
@@ -272,7 +241,6 @@ describe DeepHash do
     end
   end
 
-
   describe "#values_at" do
     before(:each) do
       @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
@@ -283,69 +251,244 @@ describe DeepHash do
     end
   end
 
-  describe "#symbolize_keys" do
+  it 'responds to #symbolize_keys, #symbolize_keys! and #stringify_keys but not #stringify_keys!' do
+    DeepHash.new.should respond_to(:symbolize_keys )
+    DeepHash.new.should respond_to(:symbolize_keys!)
+    DeepHash.new.should respond_to(:stringify_keys )
+    DeepHash.new.should_not respond_to(:stringify_keys!)
+  end
+
+  describe '#symbolize_keys' do
+    it 'returns a dup of itself' do
+      deep_hash = DeepHash.new(@hash)
+      deep_hash.symbolize_keys.should == deep_hash
+    end
+  end
+
+  describe '#symbolize_keys!' do
     it 'with bang returns the deep_hash itself' do
       deep_hash = DeepHash.new(@hash)
       deep_hash.symbolize_keys!.object_id.should == deep_hash.object_id
     end
+  end
 
-    it 'returns a dup of itself' do
-      deep_hash = DeepHash.new(@hash)
-      deep_hash.symbolize_keys.should == deep_hash
+  describe '#stringify_keys' do
+    it 'converts keys that are all symbols' do
+      @deep_hash.stringify_keys.should ==
+        { 'nested_1' => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, 'leaf_at_top' => 'val1b' }
+    end
+
+    it 'returns a Hash, not a DeepHash' do
+      @deep_hash.stringify_keys.class.should == Hash
+      @deep_hash.stringify_keys.should_not be_a(DeepHash)
+    end
+
+    it 'only stringifies and hashifies the top level' do
+      stringified = @deep_hash.stringify_keys
+      stringified.should == { 'nested_1' => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, 'leaf_at_top' => 'val1b' }
+      stringified['nested_1'].should be_a(DeepHash)
     end
   end
 
-  describe "#reverse_merge" do
+  describe '#assert_valid_keys' do
     before do
-      @defaults  = { :a => "x", :b => "y", :c => 10 }.freeze
-      @deep_hash = DeepHash.new({ :a => 1, :b => 2 })
+      @deep_hash = DeepHash.new({ :failure => "stuff", :funny => "business" })
+    end
+
+    it 'is true and does not raise when valid' do
+      @deep_hash.assert_valid_keys([ :failure, :funny ]).should be_nil
+      @deep_hash.assert_valid_keys(:failure, :funny).should be_nil
+    end
+
+    it 'fails when invalid' do
+      @deep_hash[:failore] = @deep_hash.delete(:failure)
+      lambda{ @deep_hash.assert_valid_keys([ :failure, :funny ]) }.should raise_error(ArgumentError, "Unknown key(s): failore")
+      lambda{ @deep_hash.assert_valid_keys(:failure, :funny)     }.should raise_error(ArgumentError, "Unknown key(s): failore")
+    end
+  end
+
+  describe "#merge" do
+    it 'merges given Hash' do
+      merged = @deep_hash.merge(:no => "in between")
+      merged.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+    end
+
+    it 'returns a new instance' do
+      merged = @deep_hash.merge(:no => "in between")
+      merged.should_not equal(@deep_hash)
+    end
+
+    it 'returns instance of DeepHash' do
+      merged = @deep_hash.merge(:no => "in between")
+      merged.should be_an_instance_of(DeepHash)
+      merged[:no].should  == "in between"
+      merged["no"].should == "in between"
+    end
+
+    it "converts all Hash values into DeepHashes"  do
+      merged = @deep_hash.merge({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      merged[:nested_1].should be_an_instance_of(DeepHash)
+      merged[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
+      merged[:other1].should be_an_instance_of(DeepHash)
+    end
+
+    it "converts string keys to symbol keys even if they occur deep in the given hash" do
+      merged = @deep_hash.merge({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+      merged[:a].should     == { :b  => { :c  => { :d => :e }}}
+      merged[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+    end
+
+    it "DOES merge values where given hash has nil value" do
+      merged = @deep_hash.merge(:a => { :b => nil }, :c => nil, :leaf_3_also => nil)
+      merged[:a][:b].should be_nil
+      merged[:c].should be_nil
+      merged[:leaf_3_also].should be_nil
+    end
+
+    it "replaces child hashes, and does not merge them"  do
+      merged = @deep_hash.merge({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      merged.should          == { :nested_1 => { :nested_2  => { :leaf_3_also => "val3a" } }, :other1 => { :other2 => "other_val2" }, :leaf_at_top => 'val1b' }
+    end
+  end
+
+  describe "#merge!" do
+    it 'merges given Hash' do
+      @deep_hash.merge!(:no => "in between")
+      @deep_hash.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+    end
+
+    it 'returns a new instance' do
+      @deep_hash.merge!(:no => "in between")
+      @deep_hash.should equal(@deep_hash)
+    end
+
+    it 'returns instance of DeepHash' do
+      @deep_hash.merge!(:no => "in between")
+      @deep_hash.should be_an_instance_of(DeepHash)
+      @deep_hash[:no].should  == "in between"
+      @deep_hash["no"].should == "in between"
+    end
+
+    it "converts all Hash values into DeepHashes"  do
+      @deep_hash.merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      @deep_hash[:nested_1].should be_an_instance_of(DeepHash)
+      @deep_hash[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
+      @deep_hash[:other1].should be_an_instance_of(DeepHash)
+    end
+
+    it "converts string keys to symbol keys even if they occur deep in the given hash" do
+      @deep_hash.merge!({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+      @deep_hash[:a].should     == { :b  => { :c  => { :d => :e }}}
+      @deep_hash[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+    end
+
+    it "DOES merge values where given hash has nil value" do
+      @deep_hash.merge!(:a => { :b => nil }, :c => nil, :leaf_3_also => nil)
+      @deep_hash[:a][:b].should be_nil
+      @deep_hash[:c].should be_nil
+      @deep_hash[:leaf_3_also].should be_nil
+    end
+
+    it "replaces child hashes, and does not merge them"  do
+      @deep_hash = @deep_hash.merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      @deep_hash.should           == { :nested_1 => { :nested_2  => { :leaf_3_also => "val3a" } }, :other1 => { :other2  => "other_val2" }, :leaf_at_top => 'val1b' }
+      @deep_hash.should_not       == { :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }, :leaf_at_top => 'val1b' }
+    end
+  end
+
+  describe "#reverse_merge" do
+    it 'merges given Hash' do
+      @deep_hash.reverse_merge!(:no => "in between", :leaf_at_top => 'NOT_USED')
+      @deep_hash.should == { :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b', :no => 'in between' }
+    end
+
+    it 'returns a new instance' do
+      @deep_hash.reverse_merge!(:no => "in between")
+      @deep_hash.should equal(@deep_hash)
+    end
+
+    it 'returns instance of DeepHash' do
+      @deep_hash.reverse_merge!(:no => "in between")
+      @deep_hash.should be_an_instance_of(DeepHash)
+      @deep_hash[:no].should  == "in between"
+      @deep_hash["no"].should == "in between"
+    end
+
+    it "converts all Hash values into DeepHashes"  do
+      @deep_hash.reverse_merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      @deep_hash[:nested_1].should be_an_instance_of(DeepHash)
+      @deep_hash[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
+      @deep_hash[:other1].should be_an_instance_of(DeepHash)
+    end
+
+    it "converts string keys to symbol keys even if they occur deep in the given hash" do
+      merged = @deep_hash.reverse_merge({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+      merged[:a].should     == { :b  => { :c  => { :d => :e }}}
+      merged[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
     end
 
-    it 'merges defaults into options, creating a new hash' do
-      @deep_hash.reverse_merge(@defaults).should == { :a => 1, :b => 2, :c => 10 }
-      @deep_hash.should == { :a => 1, :b => 2 }
+    it "DOES merge values where given hash has nil value" do
+      @deep_hash.reverse_merge!(:a => { :b => nil }, :c => nil)
+      @deep_hash[:a][:b].should be_nil
+      @deep_hash[:c].should     be_nil
     end
 
-    it 'with bang merges! defaults into options, replacing options' do
-      @deep_hash.reverse_merge!(@defaults).should == { :a => 1, :b => 2, :c => 10 }
-      @deep_hash.should == { :a => 1, :b => 2, :c => 10 }
+    it "replaces child hashes, and does not merge them"  do
+      @deep_hash = @deep_hash.reverse_merge!({ :nested_1 => { 'nested_2' => { :leaf_3_also => "val3a" } },                     :other1 => { "other2" => "other_val2" }})
+      @deep_hash.should                   == { :nested_1 => { :nested_2  => { :leaf_3      => "val3"  }, :leaf_2 => ['arr'] }, :other1 => { :other2 => "other_val2" }, :leaf_at_top => 'val1b' }
     end
   end
 
   describe "#deep_merge!" do
     it "merges two subhashes when they share a key" do
       @deep_hash.deep_merge!(:nested_1 => { :nested_2  => { :leaf_3_also  => "val3a" } })
-      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => 'val1b' }
+      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => 'val1b' }
     end
+
     it "merges two subhashes when they share a symbolized key" do
       @deep_hash.deep_merge!(:nested_1 => { "nested_2" => { "leaf_3_also" => "val3a" } })
-      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => "val1b" }
+      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => ['arr'] }, :leaf_at_top => "val1b" }
     end
+
     it "preserves values in the original" do
       @deep_hash.deep_merge! :other_key => "other_val"
-      @deep_hash[:nested_1][:leaf_2].should == "val2"
+      @deep_hash[:nested_1][:leaf_2].should == ['arr']
       @deep_hash[:other_key].should == "other_val"
     end
-    # it "converts all Hash values into DeepHashes if param is a Hash"  do
-    #   @deep_hash.deep_merge!({:nested_1 => { :nested_2 => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
-    #   @deep_hash[:nested_1].should be_an_instance_of(DeepHash)
-    #   @deep_hash[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
-    #   @deep_hash[:other1].should be_an_instance_of(DeepHash)
-    # end
-    it "replaces values from the given DeepHash" do
+
+    it "converts all Hash values into DeepHashes"  do
+      @deep_hash.deep_merge!({:nested_1 => { :nested_2 => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+      @deep_hash[:nested_1].should be_an_instance_of(DeepHash)
+      @deep_hash[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
+      @deep_hash[:other1].should be_an_instance_of(DeepHash)
+    end
+
+    it "converts string keys to symbol keys even if they occur deep in the given hash" do
+      @deep_hash.deep_merge!({   'a' => { 'b' => { 'c' => { :d => :e }}}})
+      @deep_hash[:a].should     == { :b  => { :c  => { :d => :e }}}
+      @deep_hash[:a].should_not == { 'b' => { 'c' => { :d => :e }}}
+    end
+
+    it "replaces values from the given hash" do
       @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => "new_val3" }, :leaf_2 => { "other2" => "other_val2" }})
       @deep_hash[:nested_1][:nested_2][:leaf_3].should == 'new_val3'
       @deep_hash[:nested_1][:leaf_2].should == { :other2 => "other_val2" }
     end
 
-    it "replaces values from the given DeepHash" do
-      @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => [] }, :leaf_2 => nil }, :leaf_at_top => '')
+    it "replaces arrays and does not append to them" do
+      @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => [] }, :leaf_2 => ['val2'] })
       @deep_hash[:nested_1][:nested_2][:leaf_3].should == []
-      @deep_hash[:nested_1][:leaf_2].should == "val2"
+      @deep_hash[:nested_1][:leaf_2].should == ['val2']
+    end
+
+    it "does not replaces values where given hash has nil value" do
+      @deep_hash.deep_merge!(:nested_1 => { :leaf_2 => nil }, :leaf_at_top => '')
+      @deep_hash[:nested_1][:leaf_2].should == ['arr']
       @deep_hash[:leaf_at_top].should == ""
     end
   end
 
+
   describe "#deep_set" do
     it 'should set a new value (single arg)' do
       @deep_hash.deep_set :new_key, 'new_val'
@@ -378,7 +521,7 @@ describe DeepHash do
     it 'should remove the key from the array (multiple args)' do
       @deep_hash.deep_delete(:nested_1, :nested_2, :leaf_3)
       @deep_hash[:nested_1][:nested_2][:leaf_3].should be_nil
-      @deep_hash.should == {:leaf_at_top => "val1b", :nested_1 => {:leaf_2 => "val2", :nested_2 => {}}}
+      @deep_hash.should == {:leaf_at_top => "val1b", :nested_1 => {:leaf_2 => ['arr'], :nested_2 => {}}}
     end
     it 'should return the value if present (single args)' do
       returned_val = @deep_hash.deep_delete(:leaf_at_top)

metadata

@@ -2,7 +2,7 @@
 name: configliere
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.4.5
+  version: 0.4.6
 platform: ruby
 authors: 
 - infochimps
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-18 00:00:00 -05:00
+date: 2011-05-21 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -174,7 +174,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3183115947293832895
+      hash: 213250075244557737
       segments: 
       - 0
       version: "0"