hashie 2.1.2 → 4.1.0

data/spec/hashie/extensions/coercion_spec.rb

@@ -1,156 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Coercion do
-  class Initializable
-    attr_reader :coerced, :value
-
-    def initialize(obj, coerced = false)
-      @coerced = coerced
-      @value = obj.class.to_s
-    end
-
-    def coerced?
-      !!@coerced
-    end
-  end
-
-  class Coercable < Initializable
-    def self.coerce(obj)
-      new(obj, true)
-    end
-  end
-
-  before(:each) do
-    class ExampleCoercableHash < Hash
-      include Hashie::Extensions::Coercion
-      include Hashie::Extensions::MergeInitializer
-    end
-  end
-
-  subject { ExampleCoercableHash }
-
-  let(:instance) { subject.new }
-
-  describe '#coerce_key' do
-    it { expect(subject).to be_respond_to(:coerce_key) }
-
-    it 'runs through coerce on a specified key' do
-      subject.coerce_key :foo, Coercable
-
-      instance[:foo] = 'bar'
-      expect(instance[:foo]).to be_coerced
-    end
-
-    it 'supports an array of keys' do
-      subject.coerce_keys :foo, :bar, Coercable
-
-      instance[:foo] = 'bar'
-      instance[:bar] = 'bax'
-      expect(instance[:foo]).to be_coerced
-      expect(instance[:bar]).to be_coerced
-    end
-
-    it 'calls #new if no coerce method is available' do
-      subject.coerce_key :foo, Initializable
-
-      instance[:foo] = 'bar'
-      expect(instance[:foo].value).to eq 'String'
-      expect(instance[:foo]).not_to be_coerced
-    end
-
-    it 'coerces when the merge initializer is used' do
-      subject.coerce_key :foo, Coercable
-      instance = subject.new(foo: 'bar')
-
-      expect(instance[:foo]).to be_coerced
-    end
-
-    context 'when #replace is used' do
-      before { subject.coerce_key :foo, :bar, Coercable }
-
-      let(:instance) do
-        subject.new(foo: 'bar').replace(foo: 'foz', bar: 'baz', hi: 'bye')
-      end
-
-      it 'coerces relevant keys' do
-        expect(instance[:foo]).to be_coerced
-        expect(instance[:bar]).to be_coerced
-        expect(instance[:hi]).not_to respond_to(:coerced?)
-      end
-
-      it 'sets correct values' do
-        expect(instance[:hi]).to eq 'bye'
-      end
-    end
-
-    context 'when used with a Mash' do
-      class UserMash < Hashie::Mash
-      end
-      class TweetMash < Hashie::Mash
-        include Hashie::Extensions::Coercion
-        coerce_key :user, UserMash
-      end
-
-      it 'coerces with instance initialization' do
-        tweet = TweetMash.new(user: { email: 'foo@bar.com' })
-        expect(tweet[:user]).to be_a(UserMash)
-      end
-
-      it 'coerces when setting with attribute style' do
-        tweet = TweetMash.new
-        tweet.user = { email: 'foo@bar.com' }
-        expect(tweet[:user]).to be_a(UserMash)
-      end
-
-      it 'coerces when setting with string index' do
-        tweet = TweetMash.new
-        tweet['user'] = { email: 'foo@bar.com' }
-        expect(tweet[:user]).to be_a(UserMash)
-      end
-
-      it 'coerces when setting with symbol index' do
-        tweet = TweetMash.new
-        tweet[:user] = { email: 'foo@bar.com' }
-        expect(tweet[:user]).to be_a(UserMash)
-      end
-    end
-  end
-
-  describe '#coerce_value' do
-    context 'with strict: true' do
-      it 'coerces any value of the exact right class' do
-        subject.coerce_value String, Coercable
-
-        instance[:foo] = 'bar'
-        instance[:bar] = 'bax'
-        instance[:hi]  = :bye
-        expect(instance[:foo]).to be_coerced
-        expect(instance[:bar]).to be_coerced
-        expect(instance[:hi]).not_to respond_to(:coerced?)
-      end
-
-      it 'coerces values from a #replace call' do
-        subject.coerce_value String, Coercable
-
-        instance[:foo] = :bar
-        instance.replace(foo: 'bar', bar: 'bax')
-        expect(instance[:foo]).to be_coerced
-        expect(instance[:bar]).to be_coerced
-      end
-
-      it 'does not coerce superclasses' do
-        klass = Class.new(String)
-        subject.coerce_value klass, Coercable
-
-        instance[:foo] = 'bar'
-        expect(instance[:foo]).not_to be_kind_of(Coercable)
-        instance[:foo] = klass.new
-        expect(instance[:foo]).to be_kind_of(Coercable)
-      end
-    end
-  end
-
-  after(:each) do
-    Object.send(:remove_const, :ExampleCoercableHash)
-  end
-end

data/spec/hashie/extensions/deep_fetch_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-module Hashie
-  module Extensions
-    describe DeepFetch do
-      subject { Class.new(Hash) { include Hashie::Extensions::DeepFetch } }
-      let(:hash) do
-        {
-          library: {
-            books: [
-              { title: 'Call of the Wild' },
-              { title: 'Moby Dick' }
-            ],
-            location: {
-              address: '123 Library St.'
-            }
-          }
-        }
-      end
-      let(:instance) { subject.new.update(hash) }
-
-      describe '#deep_fetch' do
-        it 'extracts a value from a nested hash' do
-          expect(instance.deep_fetch(:library, :location, :address)).to eq('123 Library St.')
-        end
-
-        it 'extracts a value from a nested array' do
-          expect(instance.deep_fetch(:library, :books, 1, :title)).to eq('Moby Dick')
-        end
-
-        context 'when one of the keys is not present' do
-          context 'when a block is provided' do
-            it 'returns the value of the block' do
-              value = instance.deep_fetch(:library, :unknown_key, :location) { 'block value' }
-              expect(value).to eq('block value')
-            end
-          end
-
-          context 'when a block is not provided' do
-            context 'when the nested object is an array' do
-              it 'raises an UndefinedPathError' do
-                expect do
-                  instance.deep_fetch(:library, :books, 2)
-                end.to(
-                  raise_error(
-                    DeepFetch::UndefinedPathError,
-                    'Could not fetch path (library > books > 2) at 2'
-                  )
-                )
-              end
-            end
-
-            context 'when the nested object is a hash' do
-              it 'raises a UndefinedPathError' do
-                expect do
-                  instance.deep_fetch(:library, :location, :unknown_key)
-                end.to(
-                  raise_error(
-                    DeepFetch::UndefinedPathError,
-                    'Could not fetch path (library > location > unknown_key) at unknown_key'
-                  )
-                )
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::DeepMerge do
-  class DeepMergeHash < Hash
-    include Hashie::Extensions::DeepMerge
-  end
-
-  subject { DeepMergeHash }
-
-  let(:h1) { subject.new.merge(a: 'a', a1: 42, b: 'b', c: { c1: 'c1', c2: { a: 'b' }, c3: { d1: 'd1' } }) }
-  let(:h2) { { a: 1, a1: 1, c: { c1: 2, c2: 'c2', c3: { d2: 'd2' } } } }
-  let(:expected_hash) { { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } } } }
-
-  it 'deep merges two hashes' do
-    expect(h1.deep_merge(h2)).to eq expected_hash
-  end
-
-  it 'deep merges another hash in place via bang method' do
-    h1.deep_merge!(h2)
-    expect(h1).to eq expected_hash
-  end
-end

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::IgnoreUndeclared do
-  class ForgivingTrash < Hashie::Trash
-    include Hashie::Extensions::IgnoreUndeclared
-    property :city
-    property :state, from: :provence
-  end
-
-  subject { ForgivingTrash }
-
-  it 'silently ignores undeclared properties on initialization' do
-    expect { subject.new(city: 'Toronto', provence: 'ON', country: 'Canada') }.to_not raise_error
-  end
-
-  it 'works with translated properties (with symbol keys)' do
-    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
-  end
-
-  it 'works with translated properties (with string keys)' do
-    expect(subject.new(provence: 'Ontario').state).to eq('Ontario')
-  end
-end

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -1,152 +0,0 @@
-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
-
-  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
-    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
-    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(Hash.new).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 false
-        end
-      end
-
-      it 'creates new keys with indifferent access' do
-        [:bar, 'bar', :hi, 'hi'].each { |k| expect(h.key?(k)).to be true }
-        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/key_conversion_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::KeyConversion do
-  subject do
-    klass = Class.new(::Hash)
-    klass.send :include, Hashie::Extensions::KeyConversion
-    klass
-  end
-
-  let(:instance) { subject.new }
-
-  describe '#stringify_keys!' do
-    it 'converts keys to strings' do
-      instance[:abc] = 'abc'
-      instance[123] = '123'
-      instance.stringify_keys!
-      expect((instance.keys & %w(abc 123)).size).to eq 2
-    end
-
-    it 'performs deep conversion within nested hashes' do
-      instance[:ab] = subject.new
-      instance[:ab][:cd] = subject.new
-      instance[:ab][:cd][:ef] = 'abcdef'
-      instance.stringify_keys!
-      expect(instance).to eq('ab' => { 'cd' => { 'ef' => 'abcdef' } })
-    end
-
-    it 'performs deep conversion within nested arrays' do
-      instance[:ab] = []
-      instance[:ab] << subject.new
-      instance[:ab] << subject.new
-      instance[:ab][0][:cd] = 'abcd'
-      instance[:ab][1][:ef] = 'abef'
-      instance.stringify_keys!
-      expect(instance).to eq('ab' => [{ 'cd' => 'abcd' }, { 'ef' => 'abef' }])
-    end
-
-    it 'returns itself' do
-      expect(instance.stringify_keys!).to eq instance
-    end
-  end
-
-  describe '#stringify_keys' do
-    it 'converts keys to strings' do
-      instance[:abc] = 'def'
-      copy = instance.stringify_keys
-      expect(copy['abc']).to eq 'def'
-    end
-
-    it 'does not alter the original' do
-      instance[:abc] = 'def'
-      copy = instance.stringify_keys
-      expect(instance.keys).to eq [:abc]
-      expect(copy.keys).to eq %w(abc)
-    end
-  end
-
-  describe '#symbolize_keys!' do
-    it 'converts keys to symbols' do
-      instance['abc'] = 'abc'
-      instance['def'] = 'def'
-      instance.symbolize_keys!
-      expect((instance.keys & [:abc, :def]).size).to eq 2
-    end
-
-    it 'performs deep conversion within nested hashes' do
-      instance['ab'] = subject.new
-      instance['ab']['cd'] = subject.new
-      instance['ab']['cd']['ef'] = 'abcdef'
-      instance.symbolize_keys!
-      expect(instance).to eq(ab: { cd: { ef: 'abcdef' } })
-    end
-
-    it 'performs deep conversion within nested arrays' do
-      instance['ab'] = []
-      instance['ab'] << subject.new
-      instance['ab'] << subject.new
-      instance['ab'][0]['cd'] = 'abcd'
-      instance['ab'][1]['ef'] = 'abef'
-      instance.symbolize_keys!
-      expect(instance).to eq(ab: [{ cd: 'abcd' }, { ef: 'abef' }])
-    end
-
-    it 'returns itself' do
-      expect(instance.symbolize_keys!).to eq instance
-    end
-  end
-
-  describe '#symbolize_keys' do
-    it 'converts keys to symbols' do
-      instance['abc'] = 'def'
-      copy = instance.symbolize_keys
-      expect(copy[:abc]).to eq 'def'
-    end
-
-    it 'does not alter the original' do
-      instance['abc'] = 'def'
-      copy = instance.symbolize_keys
-      expect(instance.keys).to eq ['abc']
-      expect(copy.keys).to eq [:abc]
-    end
-  end
-end