hashr 0.0.6 → 0.0.7

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    hashr (0.0.5)
+    hashr (0.0.6)
 
 GEM
   remote: http://rubygems.org/

data/lib/hashr.rb

@@ -1,3 +1,5 @@
+require 'hashr/core_ext/ruby/hash'
+
 class Hashr < Hash
   autoload :EnvDefaults, 'hashr/env_defaults'
 
@@ -7,7 +9,7 @@ class Hashr < Hash
     attr_accessor :raise_missing_keys
 
     def define(definition)
-      @definition = definition
+      @definition = definition.deep_symbolize_keys
     end
 
     def definition
@@ -15,13 +17,12 @@ class Hashr < Hash
     end
   end
 
-  def initialize(data = {})
-    include_modules(data.delete(:_include)) if data
-    replace(deep_hasherize(deep_merge(self.class.definition, data)))
+  def initialize(data = {}, definition = self.class.definition)
+    replace(deep_hashrize(definition.deep_merge(data.deep_symbolize_keys)))
   end
 
   def []=(key, value)
-    super(key, value.is_a?(Hash) ? self.class.new(value) : value)
+    super(key, value.is_a?(Hash) ? self.class.new(value, {}) : value)
   end
 
   def respond_to?(name)
@@ -40,24 +41,23 @@ class Hashr < Hash
     end
   end
 
-  protected
-
-    def include_modules(modules)
-      Array(modules).each { |mod| meta_class.send(:include, mod) } if modules
-    end
+  def include_modules(modules)
+    Array(modules).each { |mod| meta_class.send(:include, mod) } if modules
+  end
 
-    def meta_class
-      class << self; self end
-    end
+  def meta_class
+    class << self; self end
+  end
 
-    def deep_merge(left, right)
-      merger = proc { |key, v1, v2| v1.is_a?(Hash) && v2.is_a?(Hash) ? self.class.new(v1.merge(v2, &merger)) : v2 }
-      left.merge(right || {}, &merger)
-    end
+  protected
 
-    def deep_hasherize(hash)
+    def deep_hashrize(hash)
       hash.inject(TEMPLATE.dup) do |result, (key, value)|
-        result[key.to_sym] = value.is_a?(Hash) ? deep_hasherize(value) : value
+        if key.to_sym == :_include
+          result.include_modules(value)
+        else
+          result.store(key.to_sym, value.is_a?(Hash) ? deep_hashrize(value) : value)
+        end
         result
       end
     end

data/lib/hashr/core_ext/ruby/hash.rb

@@ -0,0 +1,28 @@
+class Hash
+  def slice(*keep_keys)
+    h = {}
+    keep_keys.each { |key| h[key] = fetch(key) }
+    h
+  end unless Hash.method_defined?(:slice)
+
+  def except(*less_keys)
+    slice(*keys - less_keys)
+  end unless Hash.method_defined?(:except)
+
+  def deep_symbolize_keys
+    inject({}) { |result, (key, value)|
+      value = value.deep_symbolize_keys if value.is_a?(Hash)
+      result[(key.to_sym rescue key) || key] = value
+      result
+    }
+  end unless Hash.method_defined?(:deep_symbolize_keys)
+
+  # deep_merge_hash! by Stefan Rusterholz, see http://www.ruby-forum.com/topic/142809
+  MERGER = proc do |key, v1, v2|
+    Hash === v1 && Hash === v2 ? v1.merge(v2, &MERGER) : v2
+  end
+
+  def deep_merge(other)
+    merge(other, &MERGER)
+  end unless Hash.method_defined?(:deep_merge)
+end

data/lib/hashr/version.rb

@@ -1,3 +1,3 @@
 class Hashr < Hash
-  VERSION = "0.0.6"
+  VERSION = "0.0.7"
 end

data/test/hashr_test.rb

@@ -41,6 +41,24 @@ class HashrTest < Test::Unit::TestCase
     assert_equal false, Hashr.new({ :foo => { :bar => 'bar' } }).foo.baz?
   end
 
+  test 'mixing symbol and string keys in defaults and data' do
+    Symbolized  = Class.new(Hashr) { define :foo => 'foo' }
+    Stringified = Class.new(Hashr) { define 'foo' => 'foo' }
+    NoDefault   = Class.new(Hashr)
+
+    assert_equal 'foo', Symbolized.new.foo
+    assert_equal 'foo', Stringified.new.foo
+    assert_nil NoDefault.new.foo
+
+    assert_equal 'foo', Symbolized.new(:foo => 'foo').foo
+    assert_equal 'foo', Stringified.new(:foo => 'foo').foo
+    assert_equal 'foo', NoDefault.new(:foo => 'foo').foo
+
+    assert_equal 'foo', Symbolized.new('foo' => 'foo').foo
+    assert_equal 'foo', Stringified.new('foo' => 'foo').foo
+    assert_equal 'foo', NoDefault.new('foo' => 'foo').foo
+  end
+
   test 'method assignment works' do
     hashr = Hashr.new
     hashr.foo = 'foo'
@@ -94,6 +112,14 @@ class HashrTest < Test::Unit::TestCase
   end
 
   test 'a key :_include includes the given modules' do
+    klass = Class.new(Hashr) do
+      define :foo => { :_include => Module.new { def helper; 'helper'; end } }
+    end
+    hashr = klass.new(:foo => { 'helper' => 'foo' })
+    assert_equal 'helper', klass.new(:foo => { 'helper' => 'foo' }).foo.helper
+  end
+
+  test 'a key :_include includes the given modules (using defaults)' do
     klass = Class.new(Hashr) do
       define :foo => { :_include => Module.new { def helper; 'helper'; end } }
     end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: hashr
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Sven Fuchs
@@ -57,6 +57,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/hashr/core_ext/ruby/hash.rb
 - lib/hashr/env_defaults.rb
 - lib/hashr/version.rb
 - lib/hashr.rb