hashie 3.4.2 → 5.0.0

data/spec/hashie/extensions/deep_fetch_spec.rb

@@ -1,97 +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' }
-            ],
-            shelves: nil,
-            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
-
-            context 'when the nested object is missing' do
-              it 'raises an UndefinedPathError' do
-                expect do
-                  instance.deep_fetch(:library, :unknown_key, :books)
-                end.to(
-                  raise_error(
-                    DeepFetch::UndefinedPathError,
-                    'Could not fetch path (library > unknown_key > books) at unknown_key'
-                  )
-                )
-              end
-            end
-
-            context 'when the nested object is nil' do
-              it 'raises an UndefinedPathError' do
-                expect do
-                  instance.deep_fetch(:library, :shelves, :address)
-                end.to(
-                  raise_error(
-                    DeepFetch::UndefinedPathError,
-                    'Could not fetch path (library > shelves > address) at address'
-                  )
-                )
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/hashie/extensions/deep_find_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::DeepFind do
-  subject { Class.new(Hash) { include Hashie::Extensions::DeepFind } }
-  let(:hash) do
-    {
-      library: {
-        books: [
-          { title: 'Call of the Wild' },
-          { title: 'Moby Dick' }
-        ],
-        shelves: nil,
-        location: {
-          address: '123 Library St.',
-          title: 'Main Library'
-        }
-      }
-    }
-  end
-  let(:instance) { subject.new.update(hash) }
-
-  describe '#deep_find' do
-    it 'detects a value from a nested hash' do
-      expect(instance.deep_find(:address)).to eq('123 Library St.')
-    end
-
-    it 'detects a value from a nested array' do
-      expect(instance.deep_find(:title)).to eq('Call of the Wild')
-    end
-
-    it 'returns nil if it does not find a match' do
-      expect(instance.deep_find(:wahoo)).to be_nil
-    end
-  end
-
-  describe '#deep_find_all' do
-    it 'detects all values from a nested hash' do
-      expect(instance.deep_find_all(:title)).to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-    end
-
-    it 'returns nil if it does not find any matches' do
-      expect(instance.deep_find_all(:wahoo)).to be_nil
-    end
-  end
-end

data/spec/hashie/extensions/deep_locate_spec.rb

@@ -1,124 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::DeepLocate do
-  let(:hash) do
-    {
-      from: 0,
-      size: 25,
-      query: {
-        bool: {
-          must: [
-            {
-              query_string: {
-                query: 'foobar',
-                default_operator: 'AND',
-                fields: [
-                  'title^2',
-                  '_all'
-                ]
-              }
-            },
-            {
-              match: {
-                field_1: 'value_1'
-              }
-            },
-            {
-              range: {
-                lsr09: {
-                  gte: 2014
-                }
-              }
-            }
-          ],
-          should: [
-            {
-              match: {
-                field_2: 'value_2'
-              }
-            }
-          ],
-          must_not: [
-            {
-              range: {
-                lsr10: {
-                  gte: 2014
-                }
-              }
-            }
-          ]
-        }
-      }
-    }
-  end
-
-  describe '.deep_locate' do
-    context 'if called with a non-callable comparator' do
-      it 'creates a key comparator on-th-fly' do
-        expect(described_class.deep_locate(:lsr10, hash)).to eq([hash[:query][:bool][:must_not][0][:range]])
-      end
-    end
-
-    it 'locates enumerables for which the given comparator returns true for at least one element' do
-      examples = [
-        [
-          ->(key, _value, _object) { key == :fields },
-          [
-            hash[:query][:bool][:must].first[:query_string]
-          ]
-        ],
-        [
-          ->(_key, value, _object) { value.is_a?(String) && value.include?('value') },
-          [
-            hash[:query][:bool][:must][1][:match],
-            hash[:query][:bool][:should][0][:match]
-          ]
-        ],
-        [
-          lambda do |_key, _value, object|
-            object.is_a?(Array) &&
-            !object.extend(described_class).deep_locate(:match).empty?
-          end,
-          [
-            hash[:query][:bool][:must],
-            hash[:query][:bool][:should]
-          ]
-        ]
-      ]
-
-      examples.each do |comparator, expected_result|
-        expect(described_class.deep_locate(comparator, hash)).to eq(expected_result)
-      end
-    end
-
-    it 'returns an empty array if nothing was found' do
-      expect(described_class.deep_locate(:muff, foo: 'bar')).to eq([])
-    end
-  end
-
-  context 'if extending an existing object' do
-    let(:extended_hash) do
-      hash.extend(described_class)
-    end
-
-    it 'adds #deep_locate' do
-      expect(extended_hash.deep_locate(:bool)).to eq([hash[:query]])
-    end
-  end
-
-  context 'if included in a hash' do
-    let(:derived_hash_with_extension_included) do
-      Class.new(Hash) do
-        include Hashie::Extensions::DeepLocate
-      end
-    end
-
-    let(:instance) do
-      derived_hash_with_extension_included.new.update(hash)
-    end
-
-    it 'adds #deep_locate' do
-      expect(instance.deep_locate(:bool)).to eq([hash[:query]])
-    end
-  end
-end

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::DeepMerge do
-  class DeepMergeHash < Hash
-    include Hashie::Extensions::DeepMerge
-  end
-
-  subject { DeepMergeHash }
-
-  it 'should return initial hash for arguments that are not hash' do
-    hash = subject.new.merge(a: 'a')
-    expect(hash.deep_merge('abc')).to eq(hash)
-  end
-
-  context 'without &block' do
-    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
-
-  context 'with &block' do
-    let(:h1) { subject.new.merge(a: 100, b: 200, c: { c1: 100 }) }
-    let(:h2) { { b: 250, c: { c1: 200 } } }
-    let(:expected_hash) { { a: 100, b: 450, c: { c1: 300 } } }
-    let(:block) { proc { |_, this_val, other_val| this_val + other_val } }
-
-    it 'deep merges two hashes' do
-      expect(h1.deep_merge(h2, &block)).to eq expected_hash
-    end
-
-    it 'deep merges another hash in place via bang method' do
-      h1.deep_merge!(h2, &block)
-      expect(h1).to eq expected_hash
-    end
-  end
-end

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::IgnoreUndeclared do
-  context 'included in Trash' 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
-
-    it 'requires properties to be declared on assignment' do
-      hash = subject.new(city: 'Toronto')
-      expect { hash.country = 'Canada' }.to raise_error(NoMethodError)
-    end
-  end
-
-  context 'combined with DeepMerge' do
-    class ForgivingTrashWithMerge < Hashie::Trash
-      include Hashie::Extensions::DeepMerge
-      include Hashie::Extensions::IgnoreUndeclared
-      property :some_key
-    end
-
-    it 'deep merges' do
-      class ForgivingTrashWithMergeAndProperty < ForgivingTrashWithMerge
-        property :some_other_key
-      end
-      hash = ForgivingTrashWithMergeAndProperty.new(some_ignored_key: 17, some_key: 12)
-      expect(hash.deep_merge(some_other_key: 55, some_ignored_key: 18)).to eq(some_key: 12, some_other_key: 55)
-    end
-  end
-end

data/spec/hashie/extensions/indifferent_access_spec.rb

@@ -1,219 +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
-
-  class IndifferentHashWithDash < Hashie::Dash
-    include Hashie::Extensions::IndifferentAccess
-    property :foo
-  end
-
-  describe 'when included in dash' do
-    let(:params) { { foo: 'bar' } }
-    subject { IndifferentHashWithDash.new(params) }
-
-    it 'initialize with a symbol' do
-      expect(subject.foo).to eq params[:foo]
-    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
-
-      it 'returns the same instance of the hash that was set' do
-        hash = Hash.new
-        h = subject.build(foo: hash)
-        expect(h.values_at(:foo)[0]).to be(hash)
-      end
-
-      it 'returns the same instance of the array that was set' do
-        array = Array.new
-        h = subject.build(foo: array)
-        expect(h.values_at(:foo)[0]).to be(array)
-      end
-
-      it 'returns the same instance of the string that was set' do
-        str = 'my string'
-        h = subject.build(foo: str)
-        expect(h.values_at(:foo)[0]).to be(str)
-      end
-
-      it 'returns the same instance of the object that was set' do
-        object = Object.new
-        h = subject.build(foo: object)
-        expect(h.values_at(:foo)[0]).to be(object)
-      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
-
-      it 'returns the same instance of the hash that was set' do
-        hash = Hash.new
-        h = subject.build(foo: hash)
-        expect(h.fetch(:foo)).to be(hash)
-      end
-
-      it 'returns the same instance of the array that was set' do
-        array = Array.new
-        h = subject.build(foo: array)
-        expect(h.fetch(:foo)).to be(array)
-      end
-
-      it 'returns the same instance of the string that was set' do
-        str = 'my string'
-        h = subject.build(foo: str)
-        expect(h.fetch(:foo)).to be(str)
-      end
-
-      it 'returns the same instance of the object that was set' do
-        object = Object.new
-        h = subject.build(foo: object)
-        expect(h.fetch(:foo)).to be(object)
-      end
-
-      it 'yields with key name if key does not exists' do
-        h = subject.build(a: 0)
-        expect(h.fetch(:foo) { |key| ['default for', key] }).to eq ['default for', 'foo']
-      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_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) { 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