hashie 3.4.3 → 5.0.0

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) { Hash.new }
-
-    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) { 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,129 +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
-
-  context 'singleton methods' do
-    subject { Hash }
-    let(:object) { subject.new.merge('a' => 1, 'b' => { 'c' => 2 }).extend(Hashie::Extensions::SymbolizeKeys) }
-    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) { Hash.new }
-
-  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,84 +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
-      expect(stringified_hash).to eq('a' => 'hey', 123 => 'bob', 'array' => [1, 2, 3], subhash: { 'a' => 'hey', b: 'bar', 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], subhash: ClassRespondsToHash.new]
-      symbolized_hash = hash.to_hash(stringify_keys: true)
-      expect(symbolized_hash).to eq('a' => 'hey', '123' => 'bob', 'array' => [1, 2, 3], 'subhash' => { 'a' => 'hey', 'b' => 'bar', '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], subhash: ClassRespondsToHash.new]
-      symbolized_hash = hash.to_hash(symbolize_keys: true)
-      expect(symbolized_hash).to eq(:a => 'hey', :"123" => 'bob', :array => [1, 2, 3], subhash: { :a => 'hey', :b => 'bar', :'123' => 'bob', :array => [1, 2, 3] })
-    end
-  end
-end