hashie 4.0.0 → 4.1.0

data/spec/hashie/extensions/strict_key_access_spec.rb

@@ -1,109 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::StrictKeyAccess do
-  class StrictKeyAccessHash < Hash
-    include Hashie::Extensions::StrictKeyAccess
-  end
-
-  shared_examples_for 'StrictKeyAccess with valid key' do |options = {}|
-    before { pending_for(options[:pending]) } if options[:pending]
-    context 'set' do
-      let(:new_value) { 42 }
-      it('returns value') do
-        expect(instance.send(:[]=, valid_key, new_value)).to eq new_value
-      end
-    end
-    context 'access' do
-      it('returns value') do
-        expect(instance[valid_key]).to eq valid_value
-      end
-    end
-    context 'lookup' do
-      it('returns key') do
-        expect(instance.key(valid_value)).to eq valid_key
-      end
-    end
-  end
-  shared_examples_for 'StrictKeyAccess with invalid key' do |options = {}|
-    before { pending_for(options[:pending]) } if options[:pending]
-    context 'access' do
-      it('raises an error') do
-        # Formatting of the error message varies on Rubinius and ruby-head
-        expect { instance[invalid_key] }.to raise_error KeyError
-      end
-    end
-    context 'lookup' do
-      it('raises an error') do
-        # Formatting of the error message does not vary here because raised by StrictKeyAccess
-        expect { instance.key(invalid_value) }.to raise_error KeyError
-      end
-    end
-  end
-  shared_examples_for 'StrictKeyAccess raises KeyError instead of allowing defaults' do
-    context '#default' do
-      it 'raises an error' do
-        expect { instance.default(invalid_key) }
-          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
-      end
-    end
-    context '#default=' do
-      it 'raises an error' do
-        expect { instance.default = invalid_key }
-          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
-      end
-    end
-    context '#default_proc' do
-      it 'raises an error' do
-        expect { instance.default_proc }
-          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
-      end
-    end
-    context '#default_proc=' do
-      it 'raises an error' do
-        expect { instance.default_proc = proc {} }
-          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
-      end
-    end
-  end
-
-  let(:klass) { StrictKeyAccessHash }
-  let(:instance) { StrictKeyAccessHash.new(*initialization_args) }
-  let(:initialization_args) do
-    [
-      { valid_key => valid_value }
-    ]
-  end
-  let(:valid_key) { :abc }
-  let(:valid_value) { 'def' }
-  let(:invalid_key) { :mega }
-  let(:invalid_value) { 'death' }
-
-  context '.new' do
-    context 'no defaults at initialization' do
-      let(:initialization_args) { [] }
-      before do
-        instance.merge!(valid_key => valid_value)
-      end
-      it_behaves_like 'StrictKeyAccess with valid key'
-      it_behaves_like 'StrictKeyAccess with invalid key'
-      it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
-    end
-    context 'with defaults at initialization' do
-      before do
-        instance.merge!(valid_key => valid_value)
-      end
-      it_behaves_like 'StrictKeyAccess with valid key'
-      it_behaves_like 'StrictKeyAccess with invalid key'
-      it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
-    end
-    it_behaves_like 'StrictKeyAccess with invalid key'
-    it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
-  end
-
-  context '.[]' do
-    let(:instance) { StrictKeyAccessHash[*initialization_args] }
-    it_behaves_like 'StrictKeyAccess with valid key', pending: { engine: 'rbx' }
-    it_behaves_like 'StrictKeyAccess with invalid key', pending: { engine: 'rbx' }
-    it_behaves_like 'StrictKeyAccess raises KeyError instead of allowing defaults'
-  end
-end

data/spec/hashie/extensions/stringify_keys_spec.rb

@@ -1,124 +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) { {} }
-
-    describe '.stringify_keys' do
-      include_examples 'stringify_keys'
-    end
-    describe '.stringify_keys!' do
-      include_examples 'stringify_keys!'
-    end
-  end
-
-  context 'singleton methods' do
-    subject { Hash }
-    let(:object) { subject.new.merge(a: 1, b: { c: 2 }).extend(Hashie::Extensions::StringifyKeys) }
-    let(:expected_hash) { { 'a' => 1, 'b' => { 'c' => 2 } } }
-
-    describe '.stringify_keys' do
-      it 'does not raise error' do
-        expect { object.stringify_keys } .not_to raise_error
-      end
-      it 'produces expected stringified hash' do
-        expect(object.stringify_keys).to eq(expected_hash)
-      end
-    end
-    describe '.stringify_keys!' do
-      it 'does not raise error' do
-        expect { object.stringify_keys! } .not_to raise_error
-      end
-      it 'produces expected stringified hash' do
-        expect(object.stringify_keys!).to eq(expected_hash)
-      end
-    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) { {} }
-
-  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,131 +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 & %i[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) { {} }
-
-    describe '.symbolize_keys' do
-      include_examples 'symbolize_keys'
-    end
-    describe '.symbolize_keys!' do
-      include_examples 'symbolize_keys!'
-    end
-  end
-
-  context 'singleton methods' do
-    subject { Hash }
-    let(:object) do
-      subject.new.merge('a' => 1, 'b' => { 'c' => 2 }).extend(Hashie::Extensions::SymbolizeKeys)
-    end
-    let(:expected_hash) { { a: 1, b: { c: 2 } } }
-
-    describe '.symbolize_keys' do
-      it 'does not raise error' do
-        expect { object.symbolize_keys }.not_to raise_error
-      end
-      it 'produces expected symbolized hash' do
-        expect(object.symbolize_keys).to eq(expected_hash)
-      end
-    end
-    describe '.symbolize_keys!' do
-      it 'does not raise error' do
-        expect { object.symbolize_keys! }.not_to raise_error
-      end
-      it 'produces expected symbolized hash' do
-        expect(object.symbolize_keys!).to eq(expected_hash)
-      end
-    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) { {} }
-
-  describe '.symbolize_keys' do
-    include_examples 'symbolize_keys'
-  end
-  describe '.symbolize_keys!' do
-    include_examples 'symbolize_keys!'
-  end
-end

data/spec/hashie/hash_spec.rb

@@ -1,123 +0,0 @@
-require 'spec_helper'
-
-describe Hash do
-  it 'is convertible to a Hashie::Mash' do
-    mash = Hashie::Hash[some: 'hash'].to_mash
-    expect(mash.is_a?(Hashie::Mash)).to be_truthy
-    expect(mash.some).to eq 'hash'
-  end
-
-  it '#stringify_keys! turns all keys into strings' do
-    hash = Hashie::Hash[a: 'hey', 123 => 'bob']
-    hash.stringify_keys!
-    expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => 'bob']
-  end
-
-  it '#stringify_keys! turns all keys into strings recursively' do
-    hash = Hashie::Hash[a: 'hey', 123 => { 345 => 'hey' }]
-    hash.stringify_keys!
-    expect(hash).to eq Hashie::Hash['a' => 'hey', '123' => { '345' => 'hey' }]
-  end
-
-  it '#stringify_keys returns a hash with stringified keys' do
-    hash = Hashie::Hash[a: 'hey', 123 => 'bob']
-    stringified_hash = hash.stringify_keys
-    expect(hash).to eq Hashie::Hash[a: 'hey', 123 => 'bob']
-    expect(stringified_hash).to eq Hashie::Hash['a' => 'hey', '123' => 'bob']
-  end
-
-  it '#to_hash returns a hash with same keys' do
-    hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3]]
-    stringified_hash = hash.to_hash
-    expect(stringified_hash).to eq('a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3])
-  end
-
-  it '#to_hash with stringify_keys set to true returns a hash with stringified_keys' do
-    hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3]]
-    symbolized_hash = hash.to_hash(stringify_keys: true)
-    expect(symbolized_hash).to eq('a' => 'hey', '123' => 'bob', 'array' => [1, 2, 3])
-  end
-
-  it '#to_hash with symbolize_keys set to true returns a hash with symbolized keys' do
-    hash = Hashie::Hash['a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3]]
-    symbolized_hash = hash.to_hash(symbolize_keys: true)
-    expect(symbolized_hash).to eq(a: 'hey', :"123" => 'bob', array: [1, 2, 3])
-  end
-
-  it "#to_hash should not blow up when #to_hash doesn't accept arguments" do
-    class BareCustomMash < Hashie::Mash
-      def to_hash
-        {}
-      end
-    end
-
-    h = Hashie::Hash.new
-    h[:key] = BareCustomMash.new
-    expect { h.to_hash }.not_to raise_error
-  end
-
-  describe 'when the value is an object that respond_to to_hash' do
-    class ClassRespondsToHash
-      def to_hash(options = {})
-        Hashie::Hash['a' => 'hey', b: 'bar', 123 => 'bob', 'array' => [1, 2, 3]].to_hash(options)
-      end
-    end
-
-    it '#to_hash returns a hash with same keys' do
-      hash = Hashie::Hash[
-        'a' => 'hey',
-        123 => 'bob',
-        'array' => [1, 2, 3],
-        subhash: ClassRespondsToHash.new
-      ]
-      stringified_hash = hash.to_hash
-
-      expected = {
-        'a' => 'hey',
-        123 => 'bob',
-        'array' => [1, 2, 3],
-        subhash: { 'a' => 'hey', b: 'bar', 123 => 'bob', 'array' => [1, 2, 3] }
-      }
-
-      expect(stringified_hash).to eq(expected)
-    end
-
-    it '#to_hash with stringify_keys set to true returns a hash with stringified_keys' do
-      hash = Hashie::Hash[
-        'a' => 'hey',
-        123 => 'bob',
-        'array' => [1, 2, 3],
-        subhash: ClassRespondsToHash.new
-      ]
-      symbolized_hash = hash.to_hash(stringify_keys: true)
-
-      expected = {
-        'a' => 'hey',
-        '123' => 'bob',
-        'array' => [1, 2, 3],
-        'subhash' => { 'a' => 'hey', 'b' => 'bar', '123' => 'bob', 'array' => [1, 2, 3] }
-      }
-
-      expect(symbolized_hash).to eq(expected)
-    end
-
-    it '#to_hash with symbolize_keys set to true returns a hash with symbolized keys' do
-      hash = Hashie::Hash[
-        'a' => 'hey',
-        123 => 'bob',
-        'array' => [1, 2, 3],
-        subhash: ClassRespondsToHash.new
-      ]
-      symbolized_hash = hash.to_hash(symbolize_keys: true)
-
-      expected = {
-        a: 'hey',
-        :"123" => 'bob',
-        array: [1, 2, 3],
-        subhash: { a: 'hey', b: 'bar', :'123' => 'bob', array: [1, 2, 3] }
-      }
-
-      expect(symbolized_hash).to eq(expected)
-    end
-  end
-end