configliere 0.3.4 → 0.4.4

data/lib/configliere/core_ext/hash.rb

@@ -1,108 +0,0 @@
-#
-# core_ext/hash.rb -- hash extensions
-#
-class Hash
-
-  # lambda for recursive merges
-  ::Hash::DEEP_MERGER = proc do |key,v1,v2|
-    (v1.respond_to?(:merge) && v2.respond_to?(:merge)) ? v1.merge(v2.compact, &Hash::DEEP_MERGER) : (v2.nil? ? v1 : v2)
-  end unless defined?(::Hash::DEEP_MERGER)
-
-  #
-  # Merge hashes recursively.
-  # Nothing special happens to array values
-  #
-  #     x = { :subhash => { 1 => :val_from_x, 222 => :only_in_x, 333 => :only_in_x }, :scalar => :scalar_from_x}
-  #     y = { :subhash => { 1 => :val_from_y, 999 => :only_in_y },                    :scalar => :scalar_from_y }
-  #     x.deep_merge y
-  #     => {:subhash=>{1=>:val_from_y, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_y}
-  #     y.deep_merge x
-  #     => {:subhash=>{1=>:val_from_x, 222=>:only_in_x, 333=>:only_in_x, 999=>:only_in_y}, :scalar=>:scalar_from_x}
-  #
-  # Nil values always lose.
-  #
-  #     x = {:subhash=>{:nil_in_x=>nil, 1=>:val1,}, :nil_in_x=>nil}
-  #     y = {:subhash=>{:nil_in_x=>5},              :nil_in_x=>5}
-  #     y.deep_merge x
-  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
-  #     x.deep_merge y
-  #     => {:subhash=>{1=>:val1, :nil_in_x=>5}, :nil_in_x=>5}
-  #
-  def deep_merge hsh2
-    merge hsh2, &Hash::DEEP_MERGER
-  end unless method_defined?(:deep_merge)
-
-  def deep_merge! hsh2
-    update hsh2, &Hash::DEEP_MERGER
-    self
-  end unless method_defined?(:deep_merge!)
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
-  #     x.deep_set(:subhash, :cat, :hat)
-  #     # => { 1 => :val, :subhash => { 1 => :val1,   :cat => :hat } }
-  #     x.deep_set(:subhash, 1, :newval)
-  #     # => { 1 => :val, :subhash => { 1 => :newval, :cat => :hat } }
-  #
-  #
-  def deep_set *args
-    val      = args.pop
-    last_key = args.pop
-    # dig down to last subtree (building out if necessary)
-    hsh = self
-    args.each{|key| hsh = (hsh[key] ||= self.class.new) }
-    # set leaf value
-    hsh[last_key] = val
-  end unless method_defined?(:deep_set)
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1 } }
-  #     x.deep_get(:subhash, 1)
-  #     # => :val
-  #     x.deep_get(:subhash, 2)
-  #     # => nil
-  #     x.deep_get(:subhash, 2, 3)
-  #     # => nil
-  #     x.deep_get(:subhash, 2)
-  #     # => nil
-  #
-  def deep_get *args
-    last_key = args.pop
-    # dig down to last subtree (building out if necessary)
-    hsh = args.inject(self){|h, k| h[k] || {} }
-    # get leaf value
-    hsh[last_key]
-  end unless method_defined?(:deep_get)
-
-  #
-  # Treat hash as tree of hashes:
-  #
-  #     x = { 1 => :val, :subhash => { 1 => :val1, 2 => :val2 } }
-  #     x.deep_delete(:subhash, 1)
-  #     #=> :val
-  #     x
-  #     #=> { 1 => :val, :subhash => { 2 => :val2 } }
-  #
-  def deep_delete *args
-    last_key  = args.pop
-    last_hsh  = args.empty? ? self : (deep_get(*args)||{})
-    last_hsh.delete(last_key)
-  end unless method_defined?(:deep_delete)
-
-  #
-  # remove all key-value pairs where the value is nil
-  #
-  def compact
-    reject{|key,val| val.nil? }
-  end unless method_defined?(:compact)
-  #
-  # Replace the hash with its compacted self
-  #
-  def compact!
-    replace(compact)
-  end unless method_defined?(:compact!)
-end

data/lib/configliere/core_ext/sash.rb

@@ -1,170 +0,0 @@
-require 'configliere/core_ext/hash'
-
-#
-# Hash with indifferent access
-#
-# Adapted from extlib/lib/mash.rb
-#
-class Sash < ::Hash
-
-  # @param constructor<Object>
-  #   The default value for the mash. Defaults to an empty hash.
-  #
-  # @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 
-
-  alias_method :regular_writer, :[]=    unless method_defined?(:regular_writer)
-  alias_method :regular_update, :update unless method_defined?(:regular_update)
-
-  # @param key<Object> The key to set.
-  # @param value<Object>
-  #   The value to set the key to.
-  #
-  # @see Mash#convert_key
-  # @see Mash#convert_value
-  def []=(key, value)
-    regular_writer(convert_key(key), convert_value(value))
-  end
-
-  alias_method :merge!, :update
-
-  # @param key<Object> The key to check for. This will be run through convert_key.
-  #
-  # @return [Boolean] True if the key exists in the mash.
-  def key?(key)
-    super(convert_key(key))
-  end
-
-  # def include? def has_key? def member?
-  alias_method :include?, :key?
-  alias_method :has_key?, :key?
-  alias_method :member?,  :key?
-
-  # @param key<Object> The key to fetch. This will be run through convert_key.
-  # @param *extras<Array> Default value.
-  #
-  # @return [Object] The value at key or the default value.
-  def fetch(key, *extras)
-    super(convert_key(key), *extras)
-  end
-
-  # @param *indices<Array>
-  #   The keys to retrieve values for. These will be run through +convert_key+.
-  #
-  # @return [Array] The values at each of the provided keys
-  def values_at(*indices)
-    indices.collect{|key| self[convert_key(key)]}
-  end
-
-  # @param hash<Hash> The hash to merge with the mash.
-  #
-  # @return [Mash] A new mash with the hash values merged in.
-  def merge(hash, &block)
-    self.dup.update(hash, &block)
-  end
-
-  # @param key<Object>
-  #   The key to delete from the mash.\
-  def delete(key)
-    super(convert_key(key))
-  end
-
-  # @return [Hash] The mash as a Hash with string keys.
-  def to_hash
-    Hash.new(default).merge(self)
-  end
-
-  # @param key<Object> The default value for the mash. Defaults to nil.
-  #
-  # @details [Alternatives]
-  #   If key is a Symbol and it is a key in the mash, then the default value will
-  #   be set to the value matching the key.
-  def default(key = nil)
-    if key.is_a?(String) && include?(key = key.to_sym)
-      self[key]
-    else
-      super(key)
-    end
-  end
-
-  # @param other_hash<Hash>
-  #   A hash to update values in the mash with. The keys and the values will be
-  #   converted to Mash format.
-  #
-  # @return [Mash] The updated mash.
-  def update(other_hash, &block)
-    sash = self.class.new
-    other_hash.each_pair do |key, value|
-      val = convert_value(value)
-      sash[convert_key(key)] = val
-    end
-    regular_update(sash, &block)
-  end
-
-  # Used to provide the same interface as Hash.
-  #
-  # @return [Sash] This sash unchanged.
-  def symbolize_keys!; self end
-
-  # @return [Hash] The sash as a Hash with stringified keys.
-  def stringify_keys
-    h = Hash.new(default)
-    each { |key, val| h[key.to_sym] = val }
-    h
-  end
-
-protected
-  # @param key<Object> The key to convert.
-  #
-  # @param [Object]
-  #   The converted key. If the key was a string, it will be converted to a
-  #   symbol.
-  #
-  # @api private
-  def convert_key(key)
-    key.is_a?(String) ? key.to_sym : key
-  end
-
-  # @param value<Object> The value to convert.
-  #
-  # @return [Object]
-  #   The converted value. A Hash or an Array of hashes, will be converted to
-  #   their Mash equivalents.
-  #
-  # @api private
-  def convert_value(value)
-    if value.class == Hash
-      value.to_sash
-    elsif value.is_a?(Array)
-      value.collect { |e| convert_value(e) }
-    else
-      value
-    end
-  end
-
-end
-
-
-class ::Hash
-
-  # Convert to Sash. This class has semantics of ActiveSupport's
-  # HashWithIndifferentAccess and we only have it so that people can write
-  # params[:key] instead of params['key'].
-  #
-  # @return [Mash] This hash as a Mash for string or symbol key access.
-  def to_sash
-    hash = Sash.new(self)
-    hash.default = default
-    hash
-  end
-  
-end

data/spec/configliere/core_ext/hash_spec.rb

@@ -1,78 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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 'does 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