hashie 3.4.2 → 5.0.0

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_method :build, :new
-    end
-  end
-
-  class IndifferentHashWithArrayInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias_method :build, :[]
-    end
-  end
-
-  class IndifferentHashWithTryConvertInitializer < Hash
-    include Hashie::Extensions::IndifferentAccess
-
-    class << self
-      alias_method :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(Hash.new).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/safe_assignment_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Mash::SafeAssignment do
-  class MashWithSafeAssignment < Hashie::Mash
-    include Hashie::Extensions::Mash::SafeAssignment
-  end
-
-  context 'when included in Mash' do
-    subject { MashWithSafeAssignment.new }
-
-    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 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/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

data/spec/hashie/extensions/method_access_spec.rb

@@ -1,184 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::MethodReader do
-  class ReaderHash < Hash
-    include Hashie::Extensions::MethodReader
-
-    def initialize(hash = {})
-      update(hash)
-    end
-  end
-
-  subject { ReaderHash }
-
-  it 'reads string keys from the method' do
-    expect(subject.new('awesome' => 'sauce').awesome).to eq 'sauce'
-  end
-
-  it 'reads symbol keys from the method' do
-    expect(subject.new(awesome: 'sauce').awesome).to eq 'sauce'
-  end
-
-  it 'reads nil and false values out properly' do
-    h = subject.new(nil: nil, false: false)
-    expect(h.nil).to eq nil
-    expect(h.false).to eq false
-  end
-
-  it 'raises a NoMethodError for undefined keys' do
-    expect { subject.new.awesome }.to raise_error(NoMethodError)
-  end
-
-  it 'returns false for undefined keys if key with question has been called ' do
-    expect(subject.new.awesome?).to eq false
-  end
-
-  it 'returns true for defined keys if key with question has been called' do
-    expect(subject.new(awesome: 'sauce').awesome?).to eq true
-  end
-
-  describe '#respond_to?' do
-    it 'is true for string keys' do
-      expect(subject.new('awesome' => 'sauce')).to be_respond_to(:awesome)
-    end
-
-    it 'is true for symbol keys' do
-      expect(subject.new(awesome: 'sauce')).to be_respond_to(:awesome)
-    end
-
-    it 'is false for non-keys' do
-      expect(subject.new).not_to be_respond_to(:awesome)
-    end
-  end
-end
-
-describe Hashie::Extensions::MethodWriter do
-  class WriterHash < Hash
-    include Hashie::Extensions::MethodWriter
-  end
-
-  subject { WriterHash.new }
-
-  it 'writes from a method call' do
-    subject.awesome = 'sauce'
-    expect(subject['awesome']).to eq 'sauce'
-  end
-
-  it 'converts the key using the #convert_key method' do
-    allow(subject).to receive(:convert_key).and_return(:awesome)
-    subject.awesome = 'sauce'
-    expect(subject[:awesome]).to eq 'sauce'
-  end
-
-  it 'raises NoMethodError on non equals-ending methods' do
-    expect { subject.awesome }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to? correctly' do
-    expect(subject).to be_respond_to(:abc=)
-    expect(subject).not_to be_respond_to(:abc)
-  end
-end
-
-describe Hashie::Extensions::MethodQuery do
-  class QueryHash < Hash
-    include Hashie::Extensions::MethodQuery
-
-    def initialize(hash = {})
-      update(hash)
-    end
-  end
-
-  subject { QueryHash }
-
-  it 'is true for non-nil string key values' do
-    expect(subject.new('abc' => 123)).to be_abc
-  end
-
-  it 'is true for non-nil symbol key values' do
-    expect(subject.new(abc: 123)).to be_abc
-  end
-
-  it 'is false for nil key values' do
-    expect(subject.new(abc: false)).not_to be_abc
-  end
-
-  it 'raises a NoMethodError for non-set keys' do
-    expect { subject.new.abc? }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to? for existing string keys' do
-    expect(subject.new('abc' => 'def')).to be_respond_to('abc?')
-  end
-
-  it '#respond_to? for existing symbol keys' do
-    expect(subject.new(abc: 'def')).to be_respond_to(:abc?)
-  end
-
-  it 'does not #respond_to? for non-existent keys' do
-    expect(subject.new).not_to be_respond_to('abc?')
-  end
-end
-
-describe Hashie::Extensions::MethodAccess do
-  it 'includes all of the other method mixins' do
-    klass = Class.new(Hash)
-    klass.send :include, Hashie::Extensions::MethodAccess
-    expect((klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodWriter, Hashie::Extensions::MethodQuery]).size).to eq 3
-  end
-end
-
-describe Hashie::Extensions::MethodOverridingWriter do
-  class OverridingHash < Hash
-    include Hashie::Extensions::MethodOverridingWriter
-  end
-
-  subject { OverridingHash.new }
-
-  it 'writes from a method call' do
-    subject.awesome = 'sauce'
-    expect(subject['awesome']).to eq 'sauce'
-  end
-
-  it 'convertes the key using the #convert_key method' do
-    allow(subject).to receive(:convert_key).and_return(:awesome)
-    subject.awesome = 'sauce'
-    expect(subject[:awesome]).to eq 'sauce'
-  end
-
-  it 'raises NoMethodError on non equals-ending methods' do
-    expect { subject.awesome }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to_missing? correctly' do
-    expect(subject).to respond_to(:abc=)
-    expect(subject).not_to respond_to(:abc)
-    expect(subject.method(:abc=)).not_to be_nil
-  end
-
-  context 'when writing a Hash method' do
-    before { subject.zip = 'a-dee-doo-dah' }
-
-    it 'overrides the original method' do
-      expect(subject.zip).to eq 'a-dee-doo-dah'
-    end
-
-    it 'aliases the method with two leading underscores' do
-      expect(subject.__zip).to eq [[%w(zip a-dee-doo-dah)]]
-    end
-
-    it 'does not re-alias when overriding an already overridden method' do
-      subject.zip = 'test'
-      expect(subject.zip).to eq 'test'
-      expect(subject.__zip).to eq [[%w(zip test)]]
-    end
-  end
-end
-
-describe Hashie::Extensions::MethodAccessWithOverride do
-  it 'includes all of the other method mixins' do
-    klass = Class.new(Hash)
-    klass.send :include, Hashie::Extensions::MethodAccessWithOverride
-    expect((klass.ancestors & [Hashie::Extensions::MethodReader, Hashie::Extensions::MethodOverridingWriter, Hashie::Extensions::MethodQuery]).size).to eq 3
-  end
-end

data/spec/hashie/extensions/stringify_keys_spec.rb

@@ -1,101 +0,0 @@
-require 'spec_helper'
-require 'support/module_context'
-
-def invoke(method)
-  if subject == object
-    subject.public_send(method)
-  else
-    subject.public_send(method, object)
-  end
-end
-
-shared_examples 'stringify_keys!' do
-  it 'converts keys to strings' do
-    object[:abc] = 'abc'
-    object[123] = '123'
-    invoke :stringify_keys!
-    expect((object.keys & %w(abc 123)).size).to eq 2
-  end
-
-  it 'converts nested instances of the same class' do
-    object[:ab] = dummy_class.new
-    object[:ab][:cd] = dummy_class.new
-    object[:ab][:cd][:ef] = 'abcdef'
-    invoke :stringify_keys!
-    expect(object).to eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
-  end
-
-  it 'converts nested hashes' do
-    object[:ab] = { cd: { ef: 'abcdef' } }
-    invoke :stringify_keys!
-    expect(object).to eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
-  end
-
-  it 'converts nested arrays' do
-    object[:ab] = []
-    object[:ab] << dummy_class.new
-    object[:ab] << dummy_class.new
-    object[:ab][0][:cd] = 'abcd'
-    object[:ab][1][:ef] = 'abef'
-    invoke :stringify_keys!
-    expect(object).to eq('ab' => [{ 'cd' => 'abcd' }, { 'ef' => 'abef' }])
-  end
-end
-
-shared_examples 'stringify_keys' do
-  it 'converts keys to strings' do
-    object[:abc] = 'def'
-    copy = invoke :stringify_keys
-    expect(copy['abc']).to eq 'def'
-  end
-
-  it 'does not alter the original' do
-    object[:abc] = 'def'
-    copy = invoke :stringify_keys
-    expect(object.keys).to eq [:abc]
-    expect(copy.keys).to eq %w(abc)
-  end
-end
-
-describe Hashie::Extensions::StringifyKeys do
-  include_context 'included hash module'
-  let(:object) { subject }
-
-  describe '#stringify_keys!' do
-    include_examples 'stringify_keys!'
-
-    it 'returns itself' do
-      expect(subject.stringify_keys!).to eq subject
-    end
-  end
-
-  context 'class methods' do
-    subject { described_class }
-    let(:object) { Hash.new }
-
-    describe '.stringify_keys' do
-      include_examples 'stringify_keys'
-    end
-    describe '.stringify_keys!' do
-      include_examples 'stringify_keys!'
-    end
-  end
-end
-
-describe Hashie do
-  let!(:dummy_class) do
-    klass = Class.new(::Hash)
-    klass.send :include, Hashie::Extensions::StringifyKeys
-    klass
-  end
-
-  subject { described_class }
-  let(:object) { Hash.new }
-
-  describe '.stringify_keys' do
-    include_examples 'stringify_keys'
-  end
-  describe '.stringify_keys!' do
-    include_examples 'stringify_keys!'
-  end
-end

data/spec/hashie/extensions/symbolize_keys_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-require 'support/module_context'
-
-def invoke(method)
-  if subject == object
-    subject.public_send(method)
-  else
-    subject.public_send(method, object)
-  end
-end
-
-shared_examples 'symbolize_keys!' do
-  it 'converts keys to symbols' do
-    object['abc'] = 'abc'
-    object['def'] = 'def'
-    invoke :symbolize_keys!
-    expect((object.keys & [:abc, :def]).size).to eq 2
-  end
-
-  it 'converts nested instances of the same class' do
-    object['ab'] = dummy_class.new
-    object['ab']['cd'] = dummy_class.new
-    object['ab']['cd']['ef'] = 'abcdef'
-    invoke :symbolize_keys!
-    expect(object).to eq(ab: { cd: { ef: 'abcdef' } })
-  end
-
-  it 'converts nested hashes' do
-    object['ab'] = { 'cd' => { 'ef' => 'abcdef' } }
-    invoke :symbolize_keys!
-    expect(object).to eq(ab: { cd: { ef: 'abcdef' } })
-  end
-
-  it 'performs deep conversion within nested arrays' do
-    object['ab'] = []
-    object['ab'] << dummy_class.new
-    object['ab'] << dummy_class.new
-    object['ab'][0]['cd'] = 'abcd'
-    object['ab'][1]['ef'] = 'abef'
-    new_object = invoke :symbolize_keys
-    expect(new_object).to eq(ab: [{ cd: 'abcd' }, { ef: 'abef' }])
-  end
-end
-
-shared_examples 'symbolize_keys' do
-  it 'converts keys to symbols' do
-    object['abc'] = 'def'
-    copy = invoke :symbolize_keys
-    expect(copy[:abc]).to eq 'def'
-  end
-
-  it 'does not alter the original' do
-    object['abc'] = 'def'
-    copy = invoke :symbolize_keys
-    expect(object.keys).to eq ['abc']
-    expect(copy.keys).to eq [:abc]
-  end
-end
-
-describe Hashie::Extensions::SymbolizeKeys do
-  include_context 'included hash module'
-  let(:object) { subject }
-
-  describe '#symbolize_keys!' do
-    include_examples 'symbolize_keys!'
-    let(:object) { subject }
-
-    it 'returns itself' do
-      expect(subject.symbolize_keys!).to eq subject
-    end
-  end
-
-  describe '#symbolize_keys' do
-    include_examples 'symbolize_keys'
-  end
-
-  context 'class methods' do
-    subject { described_class }
-    let(:object) { Hash.new }
-
-    describe '.symbolize_keys' do
-      include_examples 'symbolize_keys'
-    end
-    describe '.symbolize_keys!' do
-      include_examples 'symbolize_keys!'
-    end
-  end
-end
-
-describe Hashie do
-  let!(:dummy_class) do
-    klass = Class.new(::Hash)
-    klass.send :include, Hashie::Extensions::StringifyKeys
-    klass
-  end
-
-  subject { described_class }
-  let(:object) { Hash.new }
-
-  describe '.symbolize_keys' do
-    include_examples 'symbolize_keys'
-  end
-  describe '.symbolize_keys!' do
-    include_examples 'symbolize_keys!'
-  end
-end