hashr 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 865d5c744eb989eb6faa51b252a52b83ac31fd49
-  data.tar.gz: a69e87efba10818c1af7036e02d75327210dbc3b
+  metadata.gz: 71976fe0fa3a09290f4f79dae7e349480579ad9d
+  data.tar.gz: 55dd79646eaf06b86937ced119b3d4b488780de4
 SHA512:
-  metadata.gz: 1e2285af349146a905c6bcc53f5bdacc9d644f2ca48e05e69d700e18082d2285dd1b49e16670808a470e72e6ced4795ceb614d6d4eeded4310e61c9f1ffb559e
-  data.tar.gz: 993a3e986b50d2c9c34bd2ce153f2a25c10d0530962cca561880361f9080d83cdbb87f83de34b3dc11029ed88a5cf479d9de259396dc7d09b089f00d9820a336
+  metadata.gz: 3b9fe63ebf17bf22d5253887afbf67e8b090462df7b64291a89b425b1e32665b405905d1984371e13752a0d18e54f53ee700f0997b571f80291db58bd61dbfee
+  data.tar.gz: a46cc5aad1af026c325080a73a01045ef4878f66c2072da21f0265024d9a63c6e5567a53bbfacf36d926b706821639964e60d300960711cd69dae781e67f72cb

data/lib/hashr.rb

@@ -76,7 +76,7 @@ class Hashr < BasicObject
 
   def to_h
     @data.inject({}) do |hash, (key, value)|
-      hash.merge(key => value.respond_to?(:to_h) ? value.to_h : value)
+      hash.merge(key => value.is_a?(Hashr) || value.is_a?(Hash) ? value.to_h : value)
     end
   end
   alias to_hash to_h

data/lib/hashr/version.rb

@@ -1,3 +1,3 @@
 class Hashr < BasicObject
-  VERSION = '2.0.0.rc1'
+  VERSION = '2.0.0.rc2'
 end

data/spec/core_ext_spec.rb

@@ -0,0 +1,15 @@
+describe Hash do
+  describe 'deep_symbolize_keys' do
+    it 'symbolizes keys on nested hashes' do
+      hash     = { 'foo' => { 'bar' => 'bar' } }
+      expected = { :foo  => { :bar  => 'bar' } }
+      expect(hash.deep_symbolize_keys).to eq(expected)
+    end
+
+    it 'walks arrays' do
+      hash     = { 'foo' => [{ 'bar' => 'bar', 'baz' => { 'buz' => 'buz' } }] }
+      expected = { :foo  => [{ :bar  => 'bar', :baz  => { :buz  => 'buz' } }] }
+      expect(hash.deep_symbolize_keys).to eq(expected)
+    end
+  end
+end

data/spec/hashr/delegate/conditional_spec.rb

@@ -0,0 +1,19 @@
+describe Hashr::Delegate::Conditional do
+  let(:klass) { Class.new(Hashr) { include Hashr::Delegate::Conditional } }
+
+  it 'delegates key?' do
+    hashr = klass.new(foo: 'foo')
+    expect(hashr.key?(:foo)).to eq(true)
+  end
+
+  it 'delegates select' do
+    hashr = klass.new(foo: 'foo', bar: 'bar')
+    expect(hashr.select { |key, value| key == :bar }.to_h).to eq(bar: 'bar')
+  end
+
+  it 'delegates delete' do
+    hashr = klass.new(foo: 'foo', bar: 'bar')
+    hashr.delete(:foo)
+    expect(hashr.to_h).to eq(bar: 'bar')
+  end
+end

data/spec/hashr/env_spec.rb

@@ -0,0 +1,64 @@
+describe Hashr::Env do
+  let(:klass) do
+    Class.new(Hashr) do
+      extend Hashr::Env
+
+      self.env_namespace = 'hashr'
+
+      define string: 'string',
+             hash:   { key: 'value' },
+             array:  ['foo', 'bar'],
+             bool:   false
+    end
+  end
+
+  after do
+    ENV.keys.each { |key| ENV.delete(key) if key.start_with?('HASHR_') }
+  end
+
+  it 'defaults to an env var' do
+    ENV['HASHR_STRING'] = 'env string'
+    expect(klass.new.string).to eq('env string')
+  end
+
+  it 'defaults to a nested env var' do
+    ENV['HASHR_HASH_KEY'] = 'env value'
+    expect(klass.new.hash.key).to eq('env value')
+  end
+
+  describe 'type casts based on the default' do
+    describe 'to boolean' do
+      it 'true given' do
+        ENV['HASHR_BOOL'] = 'true'
+        expect(klass.new.bool).to eq(true)
+      end
+
+      it 'false given' do
+        ENV['HASHR_BOOL'] = 'false'
+        expect(klass.new.bool).to eq(false)
+      end
+
+      it 'empty string given' do
+        ENV['HASHR_BOOL'] = ''
+        expect(klass.new.bool).to eq(false)
+      end
+    end
+
+    describe 'to an array' do
+      it 'splits a comma-separated string' do
+        ENV['HASHR_ARRAY'] = 'env foo,env bar'
+        expect(klass.new.array).to eq(['env foo', 'env bar'])
+      end
+
+      it 'returns an empty array for an empty string' do
+        ENV['HASHR_ARRAY'] = ''
+        expect(klass.new.array).to eq([])
+      end
+    end
+  end
+
+  it 'data takes precedence over an env var' do
+    ENV['HASHR_STRING'] = 'env string'
+    expect(klass.new(string: 'data string').string).to eq('data string')
+  end
+end

data/spec/hashr_spec.rb

@@ -0,0 +1,266 @@
+describe Hashr do
+  describe 'initialization' do
+    it 'takes nil' do
+      expect { Hashr.new(nil) }.to_not raise_error
+    end
+
+    it 'does not explode on a numerical key' do
+      expect { Hashr.new(1 => 2) }.to_not raise_error
+    end
+
+    it 'does not explode on a true key' do
+      expect { Hashr.new(true => 'on') }.to_not raise_error
+    end
+
+    it 'raises an ArgumentError when given a string' do
+      expect { Hashr.new('foo') }.to raise_error(ArgumentError)
+    end
+
+    it 'passing a block allows to define methods on the singleton class' do
+      hashr = Hashr.new(count: 5) do
+        def count
+          @data.count
+        end
+      end
+      expect(hashr.count).to eq(5)
+    end
+  end
+
+  describe 'defined?' do
+    it 'returns true when a key is defined' do
+      hashr = Hashr.new(foo: 'foo')
+      expect(hashr.defined?(:foo)).to eq(true)
+    end
+
+    it 'returns false when a key is not defined' do
+      hashr = Hashr.new(foo: 'foo')
+      expect(hashr.defined?(:bar)).to eq(false)
+    end
+
+    it 'works with a numerical key' do
+      hashr = Hashr.new(1 => 'foo')
+      expect(hashr.defined?(1)).to eq(true)
+    end
+
+    it 'works with a true key' do
+      hashr = Hashr.new(true => 'foo')
+      expect(hashr.defined?(true)).to eq(true)
+    end
+
+    it 'is indifferent about symbols/strings (string given, symbol used)' do
+      hashr = Hashr.new('foo' => 'bar')
+      expect(hashr.defined?(:foo)).to eq(true)
+    end
+
+    it 'is indifferent about symbols/strings (symbol given, string used)' do
+      hashr = Hashr.new(foo: :bar)
+      expect(hashr.defined?('foo')).to eq(true)
+    end
+  end
+
+  describe 'hash access' do
+    it 'is indifferent about symbols/strings (string given, symbol used)' do
+      hashr = Hashr.new('foo' => { 'bar' => 'baz' })
+      expect(hashr[:foo][:bar]).to eq('baz')
+    end
+
+    it 'is indifferent about symbols/strings (symbol given, string used)' do
+      hashr = Hashr.new(foo: { bar: 'baz' })
+      expect(hashr['foo']['bar']).to eq('baz')
+    end
+
+    it 'allows accessing keys with Hash core method names (count)' do
+      expect(Hashr.new(count: 2).count).to eq(2)
+    end
+
+    it 'allows accessing keys with Hash core method names (key)' do
+      expect(Hashr.new(key: 'key').key).to eq('key')
+    end
+  end
+
+  describe 'hash assignment' do
+    let(:hashr) { Hashr.new }
+
+    it 'works with a string key' do
+      hashr['foo'] = 'foo'
+      expect(hashr.foo).to eq('foo')
+    end
+
+    it 'works with a symbol key' do
+      hashr[:foo] = 'foo'
+      expect(hashr.foo).to eq('foo')
+    end
+  end
+
+  describe 'method access' do
+    describe 'on an existing key' do
+      it 'returns the value' do
+        expect(Hashr.new(foo: 'foo').foo).to eq('foo')
+      end
+
+      it 'returns a nested hash' do
+        expect(Hashr.new(foo: { bar: 'bar' }).foo).to eq(bar: 'bar')
+      end
+
+      it 'returns a nested array' do
+        expect(Hashr.new(foo: ['bar', 'buz']).foo).to eq(['bar', 'buz'])
+      end
+    end
+
+    describe 'on an existing nested key' do
+      it 'returns the value' do
+        expect(Hashr.new(foo: { bar: 'bar' }).foo.bar).to eq('bar')
+      end
+
+      it 'returns a nested array' do
+        expect(Hashr.new(foo: { bar: ['bar', 'buz'] }).foo.bar).to eq(['bar', 'buz'])
+      end
+    end
+
+    describe 'on an non-existing key' do
+      it 'it returns nil' do
+        expect(Hashr.new(foo: 'foo').bar).to eq(nil)
+      end
+
+      it 'it returns nil (nested key)' do
+        expect(Hashr.new(foo: { bar: 'bar' }).foo.baz).to eq(nil)
+      end
+    end
+
+    describe 'predicate methods' do
+      it 'returns true if the key has a value' do
+        expect(Hashr.new(foo: { bar: 'bar' }).foo.bar?).to eq(true)
+      end
+
+      it 'returns false if the key does not have a value' do
+        expect(Hashr.new(foo: { bar: 'bar' }).foo.baz?).to eq(false)
+      end
+    end
+
+    describe 'respond_to?' do
+      it 'returns true for existing keys' do
+        expect(Hashr.new(foo: 'bar').respond_to?(:foo)).to eq(true)
+      end
+
+      it 'returns false for missing keys' do
+        expect(Hashr.new.respond_to?(:foo)).to eq(true)
+      end
+    end
+  end
+
+  describe 'method assignment' do
+    let(:hashr) { Hashr.new }
+
+    it 'assigns a string' do
+      hashr.foo = 'foo'
+      expect(hashr.foo).to eq('foo')
+    end
+
+    it 'converts a hash into a Hashr instance' do
+      hashr.foo = { bar: { baz: 'baz' } }
+      expect(hashr.foo.bar.baz).to eq('baz')
+    end
+  end
+
+  describe 'values_at' do
+    let(:hashr) { Hashr.new(foo: 'foo', bar: 'bar') }
+
+    it 'returns values for the given keys' do
+      expect(hashr.values_at(:foo, :bar)).to eq(['foo', 'bar'])
+    end
+  end
+
+  describe 'is_a?' do
+    let(:klass) { Class.new(Class.new(Hashr)) { default foo: 'foo' } }
+
+    it 'returns true if the object has the given superclass' do
+      expect(klass.new.is_a?(Hashr)).to eq(true)
+    end
+
+    it 'returns false if the object does not have the given superclass' do
+      expect(klass.new.is_a?(Hash)).to eq(false)
+    end
+  end
+
+  describe 'conversion' do
+    let(:hash) { Hashr.new(foo: { 'bar' => 'baz' }).to_h }
+
+    it 'converts the Hashr instance to a hash' do
+      expect(hash.class).to eq(Hash)
+    end
+
+    it 'converts nested instances to hashes' do
+      expect(hash[:foo].class).to eq(Hash)
+    end
+
+    it 'populates the hash with the symbolized keys' do
+      expect(hash[:foo][:bar]).to eq('baz')
+    end
+  end
+
+  describe 'defaults' do
+    describe 'using a symbolized hash' do
+      let(:klass) { Class.new(Hashr) { default foo: 'foo' } }
+
+      it 'defines the default' do
+        expect(klass.new['foo']).to eq('foo')
+      end
+    end
+
+    describe 'using a stringified hash' do
+      let(:klass) { Class.new(Hashr) { default 'foo' => 'foo' } }
+
+      it 'defines the default' do
+        expect(klass.new[:foo]).to eq('foo')
+      end
+    end
+
+    describe 'with a nested hash' do
+      let(:klass) { Class.new(Hashr) { default foo: { bar: { baz: 'baz' } } } }
+
+      it 'defines the default' do
+        expect(klass.new['foo'][:bar]['baz']).to eq('baz')
+      end
+    end
+
+    describe 'with a nested array' do
+      let(:klass) { Class.new(Hashr) { default foo: ['bar'] } }
+
+      it 'defines the default' do
+        expect(klass.new.foo.first).to eq('bar')
+      end
+    end
+
+    describe 'keeps existing defaults' do
+      let(:klass) { Class.new(Hashr) { default foo: 'foo'; default bar: 'bar' } }
+
+      it 'defines the existing default' do
+        expect(klass.new.foo).to eq('foo')
+      end
+
+      it 'defines the new default' do
+        expect(klass.new.bar).to eq('bar')
+      end
+    end
+
+    describe 'deep_merges inherited defaults' do
+      let(:klass) { Class.new(Class.new(Hashr) { default foo: 'foo' }) { default bar: 'bar' } }
+
+      it 'defines the inherited default' do
+        expect(klass.new.foo).to eq('foo')
+      end
+
+      it 'defines the default' do
+        expect(klass.new.bar).to eq('bar')
+      end
+    end
+  end
+
+  describe 'constant lookup' do
+    let(:klass) { Class.new(Hashr) { def env; ENV; end } }
+
+    it 'finds global consts' do
+      expect(klass.new.env).to eq(ENV)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'hashr'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hashr
 version: !ruby/object:Gem::Version
-  version: 2.0.0.rc1
+  version: 2.0.0.rc2
 platform: ruby
 authors:
 - Sven Fuchs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-07 00:00:00.000000000 Z
+date: 2015-10-15 00:00:00.000000000 Z
 dependencies: []
 description: Simple Hash extension to make working with nested hashes (e.g. for configuration)
   easier and less error-prone.
@@ -26,6 +26,11 @@ files:
 - lib/hashr/delegate/hash.rb
 - lib/hashr/env.rb
 - lib/hashr/version.rb
+- spec/core_ext_spec.rb
+- spec/hashr/delegate/conditional_spec.rb
+- spec/hashr/env_spec.rb
+- spec/hashr_spec.rb
+- spec/spec_helper.rb
 homepage: http://github.com/svenfuchs/hashr
 licenses: []
 metadata: {}