hashie 3.6.0 → 5.0.0

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -1,295 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::IndifferentAccess do
-  class IndifferentHashWithMergeInitializer < Hash
-    include Hashie::Extensions::MergeInitializer
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build new
-    end
-  end
-
-  class IndifferentHashWithArrayInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build []
-    end
-  end
-
-  class IndifferentHashWithTryConvertInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build try_convert
-    end
-  end
-
-  class IndifferentHashWithDash < Hashie::Dash
-    include Hashie::Extensions::IndifferentAccess
-    property :foo
-  end
-
-  class IndifferentHashWithIgnoreUndeclaredAndPropertyTranslation < Hashie::Dash
-    include Hashie::Extensions::IgnoreUndeclared
-    include Hashie::Extensions::Dash::PropertyTranslation
-    include Hashie::Extensions::IndifferentAccess
-    property :foo, from: :bar
-  end
-
-  describe '#merge' do
-    it 'indifferently merges in a hash' do
-      indifferent_hash = Class.new(::Hash) do
-        include Hashie::Extensions::IndifferentAccess
-      end.new
-
-      merged_hash = indifferent_hash.merge(cat: 'meow')
-
-      expect(merged_hash[:cat]).to eq('meow')
-      expect(merged_hash['cat']).to eq('meow')
-    end
-
-    it 'injects the resulting new Hash with IndifferentAccess' do
-      hash = IndifferentHashWithMergeInitializer.new(
-        :cat => 'meow',
-        'dog' => { name: 'Mango', sound: 'woof' }
-      )
-
-      dog = hash[:dog]
-      merged = dog.merge(foo: 'bar')
-
-      expect(merged[:foo]).to eq('bar')
-      expect(merged['foo']).to eq('bar')
-    end
-  end
-
-  describe '#merge!' do
-    it 'indifferently merges in a hash' do
-      indifferent_hash = Class.new(::Hash) do
-        include Hashie::Extensions::IndifferentAccess
-      end.new
-
-      indifferent_hash[:cat] = 'meow'
-
-      expect(indifferent_hash[:cat]).to eq('meow')
-      expect(indifferent_hash['cat']).to eq('meow')
-    end
-  end
-
-  describe 'when included in dash' do
-    let(:params) { { foo: 'bar' } }
-    subject { IndifferentHashWithDash.new(params) }
-
-    it 'initialize with a symbol' do
-      expect(subject.foo).to eq params[:foo]
-    end
-  end
-
-  describe 'when translating properties and ignoring undeclared' do
-    let(:value) { 'baz' }
-
-    subject { IndifferentHashWithIgnoreUndeclaredAndPropertyTranslation.new(params) }
-
-    context 'and the hash keys are strings' do
-      let(:params) { { 'bar' => value } }
-
-      it 'sets the property' do
-        expect(subject[:foo]).to eq value
-      end
-    end
-
-    context 'and the hash keys are symbols' do
-      let(:params) { { bar: 'baz' } }
-
-      it 'sets the property' do
-        expect(subject[:foo]).to eq value
-      end
-    end
-
-    context 'and there are undeclared keys' do
-      let(:params) { { 'bar' => 'baz', 'fail' => false } }
-
-      it 'sets the property' do
-        expect(subject[:foo]).to eq value
-      end
-    end
-  end
-
-  shared_examples_for 'hash with indifferent access' do
-    it 'is able to access via string or symbol' do
-      h = subject.build(abc: 123)
-      expect(h[:abc]).to eq 123
-      expect(h['abc']).to eq 123
-    end
-
-    describe '#values_at' do
-      it 'indifferently finds values' do
-        h = subject.build(:foo => 'bar', 'baz' => 'qux')
-        expect(h.values_at('foo', :baz)).to eq %w[bar qux]
-      end
-
-      it 'returns the same instance of the hash that was set' do
-        hash = {}
-        h = subject.build(foo: hash)
-        expect(h.values_at(:foo)[0]).to be(hash)
-      end
-
-      it 'returns the same instance of the array that was set' do
-        array = []
-        h = subject.build(foo: array)
-        expect(h.values_at(:foo)[0]).to be(array)
-      end
-
-      it 'returns the same instance of the string that was set' do
-        str = 'my string'
-        h = subject.build(foo: str)
-        expect(h.values_at(:foo)[0]).to be(str)
-      end
-
-      it 'returns the same instance of the object that was set' do
-        object = Object.new
-        h = subject.build(foo: object)
-        expect(h.values_at(:foo)[0]).to be(object)
-      end
-    end
-
-    describe '#fetch' do
-      it 'works like normal fetch, but indifferent' do
-        h = subject.build(foo: 'bar')
-        expect(h.fetch(:foo)).to eq h.fetch('foo')
-        expect(h.fetch(:foo)).to eq 'bar'
-      end
-
-      it 'returns the same instance of the hash that was set' do
-        hash = {}
-        h = subject.build(foo: hash)
-        expect(h.fetch(:foo)).to be(hash)
-      end
-
-      it 'returns the same instance of the array that was set' do
-        array = []
-        h = subject.build(foo: array)
-        expect(h.fetch(:foo)).to be(array)
-      end
-
-      it 'returns the same instance of the string that was set' do
-        str = 'my string'
-        h = subject.build(foo: str)
-        expect(h.fetch(:foo)).to be(str)
-      end
-
-      it 'returns the same instance of the object that was set' do
-        object = Object.new
-        h = subject.build(foo: object)
-        expect(h.fetch(:foo)).to be(object)
-      end
-
-      it 'yields with key name if key does not exists' do
-        h = subject.build(a: 0)
-        expect(h.fetch(:foo) { |key| ['default for', key] }).to eq ['default for', 'foo']
-      end
-    end
-
-    describe '#delete' do
-      it 'deletes indifferently' do
-        h = subject.build(:foo => 'bar', 'baz' => 'qux')
-        h.delete('foo')
-        h.delete(:baz)
-        expect(h).to be_empty
-      end
-    end
-
-    describe '#key?' do
-      let(:h) { subject.build(foo: 'bar') }
-
-      it 'finds it indifferently' do
-        expect(h).to be_key(:foo)
-        expect(h).to be_key('foo')
-      end
-
-      %w[include? member? has_key?].each do |key_alias|
-        it "is aliased as #{key_alias}" do
-          expect(h.send(key_alias.to_sym, :foo)).to be(true)
-          expect(h.send(key_alias.to_sym, 'foo')).to be(true)
-        end
-      end
-    end
-
-    describe '#update' do
-      let(:h) { subject.build(foo: 'bar') }
-
-      it 'allows keys to be indifferent still' do
-        h.update(baz: 'qux')
-        expect(h['foo']).to eq 'bar'
-        expect(h['baz']).to eq 'qux'
-      end
-
-      it 'recursively injects indifference into sub-hashes' do
-        h.update(baz: { qux: 'abc' })
-        expect(h['baz']['qux']).to eq 'abc'
-      end
-
-      it 'does not change the ancestors of the injected object class' do
-        h.update(baz: { qux: 'abc' })
-        expect({}).not_to be_respond_to(:indifferent_access?)
-      end
-    end
-
-    describe '#replace' do
-      let(:h) { subject.build(foo: 'bar').replace(bar: 'baz', hi: 'bye') }
-
-      it 'returns self' do
-        expect(h).to be_a(subject)
-      end
-
-      it 'removes old keys' do
-        [:foo, 'foo'].each do |k|
-          expect(h[k]).to be_nil
-          expect(h.key?(k)).to be_falsy
-        end
-      end
-
-      it 'creates new keys with indifferent access' do
-        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be_truthy }
-        expect(h[:bar]).to eq 'baz'
-        expect(h['bar']).to eq 'baz'
-        expect(h[:hi]).to eq 'bye'
-        expect(h['hi']).to eq 'bye'
-      end
-    end
-
-    describe '#try_convert' do
-      describe 'with conversion' do
-        let(:h) { subject.try_convert(foo: 'bar') }
-
-        it 'is a subject' do
-          expect(h).to be_a(subject)
-        end
-      end
-
-      describe 'without conversion' do
-        let(:h) { subject.try_convert('{ :foo => bar }') }
-
-        it 'is nil' do
-          expect(h).to be_nil
-        end
-      end
-    end
-  end
-
-  describe 'with merge initializer' do
-    subject { IndifferentHashWithMergeInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-
-  describe 'with array initializer' do
-    subject { IndifferentHashWithArrayInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-
-  describe 'with try convert initializer' do
-    subject { IndifferentHashWithTryConvertInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-end

data/spec/hashie/extensions/indifferent_access_with_rails_hwia_spec.rb

@@ -1,208 +0,0 @@
-# This set of tests verifies that Hashie::Extensions::IndifferentAccess works with
-# ActiveSupport HashWithIndifferentAccess hashes. See #164 and #166 for details.
-
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/hash'
-require 'spec_helper'
-
-describe Hashie::Extensions::IndifferentAccess do
-  class IndifferentHashWithMergeInitializer < Hash
-    include Hashie::Extensions::MergeInitializer
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build new
-    end
-  end
-
-  class IndifferentHashWithArrayInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build []
-    end
-  end
-
-  class IndifferentHashWithTryConvertInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias build try_convert
-    end
-  end
-
-  class CoercableHash < Hash
-    include Hashie::Extensions::Coercion
-    include Hashie::Extensions::MergeInitializer
-  end
-
-  class MashWithIndifferentAccess < Hashie::Mash
-    include Hashie::Extensions::IndifferentAccess
-  end
-
-  shared_examples_for 'hash with indifferent access' do
-    it 'is able to access via string or symbol' do
-      indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(abc: 123)
-      h = subject.build(indifferent_hash)
-      expect(h[:abc]).to eq 123
-      expect(h['abc']).to eq 123
-    end
-
-    describe '#values_at' do
-      it 'indifferently finds values' do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(
-          :foo => 'bar', 'baz' => 'qux'
-        )
-        h = subject.build(indifferent_hash)
-        expect(h.values_at('foo', :baz)).to eq %w[bar qux]
-      end
-    end
-
-    describe '#fetch' do
-      it 'works like normal fetch, but indifferent' do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
-        h = subject.build(indifferent_hash)
-        expect(h.fetch(:foo)).to eq h.fetch('foo')
-        expect(h.fetch(:foo)).to eq 'bar'
-      end
-    end
-
-    describe '#delete' do
-      it 'deletes indifferently' do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(
-          :foo => 'bar',
-          'baz' => 'qux'
-        )
-        h = subject.build(indifferent_hash)
-        h.delete('foo')
-        h.delete(:baz)
-        expect(h).to be_empty
-      end
-    end
-
-    describe '#key?' do
-      let(:h) do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
-        subject.build(indifferent_hash)
-      end
-
-      it 'finds it indifferently' do
-        expect(h).to be_key(:foo)
-        expect(h).to be_key('foo')
-      end
-
-      %w[include? member? has_key?].each do |key_alias|
-        it "is aliased as #{key_alias}" do
-          expect(h.send(key_alias.to_sym, :foo)).to be(true)
-          expect(h.send(key_alias.to_sym, 'foo')).to be(true)
-        end
-      end
-    end
-
-    describe '#update' do
-      let(:h) do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
-        subject.build(indifferent_hash)
-      end
-
-      it 'allows keys to be indifferent still' do
-        h.update(baz: 'qux')
-        expect(h['foo']).to eq 'bar'
-        expect(h['baz']).to eq 'qux'
-      end
-
-      it 'recursively injects indifference into sub-hashes' do
-        h.update(baz: { qux: 'abc' })
-        expect(h['baz']['qux']).to eq 'abc'
-      end
-
-      it 'does not change the ancestors of the injected object class' do
-        h.update(baz: { qux: 'abc' })
-        expect({}).not_to be_respond_to(:indifferent_access?)
-      end
-    end
-
-    describe '#replace' do
-      let(:h) do
-        indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
-        subject.build(indifferent_hash).replace(bar: 'baz', hi: 'bye')
-      end
-
-      it 'returns self' do
-        expect(h).to be_a(subject)
-      end
-
-      it 'removes old keys' do
-        [:foo, 'foo'].each do |k|
-          expect(h[k]).to be_nil
-          expect(h.key?(k)).to be_falsy
-        end
-      end
-
-      it 'creates new keys with indifferent access' do
-        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be_truthy }
-        expect(h[:bar]).to eq 'baz'
-        expect(h['bar']).to eq 'baz'
-        expect(h[:hi]).to eq 'bye'
-        expect(h['hi']).to eq 'bye'
-      end
-    end
-
-    describe '#try_convert' do
-      describe 'with conversion' do
-        let(:h) do
-          indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(foo: 'bar')
-          subject.try_convert(indifferent_hash)
-        end
-
-        it 'is a subject' do
-          expect(h).to be_a(subject)
-        end
-      end
-
-      describe 'without conversion' do
-        let(:h) { subject.try_convert('{ :foo => bar }') }
-
-        it 'is nil' do
-          expect(h).to be_nil
-        end
-      end
-    end
-  end
-
-  describe 'with merge initializer' do
-    subject { IndifferentHashWithMergeInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-
-  describe 'with array initializer' do
-    subject { IndifferentHashWithArrayInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-
-  describe 'with try convert initializer' do
-    subject { IndifferentHashWithTryConvertInitializer }
-    it_should_behave_like 'hash with indifferent access'
-  end
-
-  describe 'with coercion' do
-    subject { CoercableHash }
-
-    let(:instance) { subject.new }
-
-    it 'supports coercion for ActiveSupport::HashWithIndifferentAccess' do
-      subject.coerce_key :foo, ActiveSupport::HashWithIndifferentAccess.new(Coercable => Coercable)
-      instance[:foo] = { 'bar_key' => 'bar_value', 'bar2_key' => 'bar2_value' }
-      expect(instance[:foo].keys).to all(be_coerced)
-      expect(instance[:foo].values).to all(be_coerced)
-      expect(instance[:foo]).to be_a(ActiveSupport::HashWithIndifferentAccess)
-    end
-  end
-
-  describe 'Mash with indifferent access' do
-    it 'is able to be created for a deep nested HashWithIndifferentAccess' do
-      indifferent_hash = ActiveSupport::HashWithIndifferentAccess.new(abc: { def: 123 })
-      MashWithIndifferentAccess.new(indifferent_hash)
-    end
-  end
-end

data/spec/hashie/extensions/key_conversion_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'support/module_context'
-
-describe Hashie::Extensions::KeyConversion do
-  include_context 'included hash module'
-
-  it { should respond_to(:stringify_keys) }
-  it { should respond_to(:stringify_keys!) }
-
-  it { should respond_to(:symbolize_keys) }
-  it { should respond_to(:symbolize_keys!) }
-end

data/spec/hashie/extensions/mash/keep_original_keys_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hashie::Extensions::Mash::KeepOriginalKeys do
-  let(:keeping_mash) do
-    Class.new(Hashie::Mash) do
-      include Hashie::Extensions::Mash::KeepOriginalKeys
-    end
-  end
-
-  it 'keeps the keys in the resulting hash identical to the original' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash.to_hash).to eq(original)
-  end
-
-  it 'indifferently responds to keys' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash['a']).to eq(mash[:a])
-    expect(mash['b']).to eq(mash[:b])
-  end
-
-  it 'responds to all method accessors like a Mash' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash.a).to eq('apple')
-    expect(mash.a?).to eq(true)
-    expect(mash.b).to eq('bottle')
-    expect(mash.b?).to eq(true)
-    expect(mash.underbang_).to be_a(keeping_mash)
-    expect(mash.bang!).to be_a(keeping_mash)
-    expect(mash.predicate?).to eq(false)
-  end
-
-  it 'keeps the keys that are directly passed without converting them' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    mash[:c] = 'cat'
-    mash['d'] = 'dog'
-    expect(mash.to_hash).to eq(:a => 'apple', 'b' => 'bottle', :c => 'cat', 'd' => 'dog')
-  end
-end

data/spec/hashie/extensions/mash/safe_assignment_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Mash::SafeAssignment do
-  class MashWithSafeAssignment < Hashie::Mash
-    include Hashie::Extensions::Mash::SafeAssignment
-
-    private
-
-    def my_own_private
-      :hello!
-    end
-  end
-
-  context 'when included in Mash' do
-    subject { MashWithSafeAssignment.new }
-
-    context 'when not attempting to override a method' do
-      it 'assigns just fine' do
-        expect do
-          subject.blabla = 'Test'
-          subject.blabla = 'Test'
-        end.to_not raise_error
-      end
-    end
-
-    context 'when attempting to override a method' do
-      it 'raises an error' do
-        expect { subject.zip = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when attempting to override a private method' do
-      it 'raises an error' do
-        expect { subject.my_own_private = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when attempting to initialize with predefined method' do
-      it 'raises an error' do
-        expect { MashWithSafeAssignment.new(zip: true) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when setting as a hash key' do
-      it 'still raises if conflicts with a method' do
-        expect { subject[:zip] = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/hashie/extensions/mash/symbolize_keys_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hashie::Extensions::Mash::SymbolizeKeys do
-  it 'raises an error when included in a class that is not a Mash' do
-    expect do
-      Class.new do
-        include Hashie::Extensions::Mash::SymbolizeKeys
-      end
-    end.to raise_error(ArgumentError)
-  end
-
-  it 'symbolizes all keys in the Mash' do
-    my_mash = Class.new(Hashie::Mash) do
-      include Hashie::Extensions::Mash::SymbolizeKeys
-    end
-
-    expect(my_mash.new('test' => 'value').to_h).to eq(test: 'value')
-  end
-
-  context 'implicit to_hash on double splat' do
-    let(:destructure) { ->(**opts) { opts } }
-    let(:my_mash) do
-      Class.new(Hashie::Mash) do
-        include Hashie::Extensions::Mash::SymbolizeKeys
-      end
-    end
-    let(:instance) { my_mash.new('outer' => { 'inner' => 42 }, 'testing' => [1, 2, 3]) }
-
-    subject { destructure.call(instance) }
-
-    it 'is converted on method calls' do
-      expect(subject).to eq(outer: { inner: 42 }, testing: [1, 2, 3])
-    end
-
-    it 'is converted on explicit operator call' do
-      expect(**instance).to eq(outer: { inner: 42 }, testing: [1, 2, 3])
-    end
-  end
-end

data/spec/hashie/extensions/merge_initializer_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::MergeInitializer do
-  class MergeInitializerHash < Hash
-    include Hashie::Extensions::MergeInitializer
-  end
-
-  subject { MergeInitializerHash }
-
-  it 'initializes with no arguments' do
-    expect(subject.new).to eq({})
-  end
-
-  it 'initializes with a hash' do
-    expect(subject.new(abc: 'def')).to eq(abc: 'def')
-  end
-
-  it 'initializes with a hash and a default' do
-    h = subject.new({ abc: 'def' }, 'bar')
-    expect(h[:foo]).to eq 'bar'
-    expect(h[:abc]).to eq 'def'
-  end
-end