hashie 3.5.7 → 5.0.0

data/spec/hashie/extensions/method_access_spec.rb

@@ -1,188 +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).abc?).to eq true
-  end
-
-  it 'is true for non-nil symbol key values' do
-    expect(subject.new(abc: 123).abc?).to eq true
-  end
-
-  it 'is false for false key values' do
-    expect(subject.new(abc: false).abc?).to eq false
-  end
-
-  it 'is false for nil key values' do
-    expect(subject.new(abc: nil).abc?).to eq false
-  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/strict_key_access_spec.rb

@@ -1,110 +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,
-                                                              %(key not found with value of #{invalid_value.inspect})
-      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,
-                                                                'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
-      end
-    end
-    context '#default=' do
-      it 'raises an error' do
-        expect { instance.default = invalid_key }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
-                                                                 'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
-      end
-    end
-    context '#default_proc' do
-      it 'raises an error' do
-        expect { instance.default_proc }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
-                                                        'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
-      end
-    end
-    context '#default_proc=' do
-      it 'raises an error' do
-        expect { instance.default_proc = proc {} }.to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError,
-                                                                  'Setting or using a default with Hashie::Extensions::StrictKeyAccess does not make sense'
-      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) { 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