hashie 4.0.0 → 4.1.0

data/spec/hashie/extensions/dash/coercion_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Dash::Coercion do
-  class DashWithCoercion < Hashie::Dash
-    include Hashie::Extensions::Dash::Coercion
-
-    property :type, coerce: Symbol
-  end
-
-  it 'does the coercion of properties' do
-    expect(DashWithCoercion.new(type: 'something')).to eq(type: :something)
-  end
-end

data/spec/hashie/extensions/dash/indifferent_access_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Dash::IndifferentAccess do
-  class TrashWithIndifferentAccess < Hashie::Trash
-    include Hashie::Extensions::Dash::IndifferentAccess
-    property :per_page, transform_with: ->(v) { v.to_i }
-    property :total, from: :total_pages
-  end
-
-  class DashWithIndifferentAccess < Hashie::Dash
-    include Hashie::Extensions::Dash::IndifferentAccess
-    property :name
-  end
-
-  context 'when included in Trash' do
-    let(:params) { { per_page: '1', total_pages: 2 } }
-    subject { TrashWithIndifferentAccess.new(params) }
-
-    it 'gets the expected behaviour' do
-      expect(subject.per_page).to eq params[:per_page].to_i
-      expect(subject.total).to eq params[:total_pages]
-    end
-  end
-
-  context 'when included in Dash' do
-    let(:patch) { Hashie::Extensions::Dash::IndifferentAccess::ClassMethods }
-    let(:dash_class) { Class.new(Hashie::Dash) }
-
-    it 'extends with the patch once' do
-      expect(patch).to receive(:extended).with(dash_class).once
-      dash_class.send(:include, Hashie::Extensions::Dash::IndifferentAccess)
-    end
-  end
-
-  context 'initialized with' do
-    it 'string' do
-      instance = DashWithIndifferentAccess.new('name' => 'Name')
-      expect(instance.name).to eq('Name')
-      expect(instance['name']).to eq('Name')
-      expect(instance[:name]).to eq('Name')
-      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Name">')
-      expect(instance.to_hash).to eq('name' => 'Name')
-    end
-
-    it 'key' do
-      instance = DashWithIndifferentAccess.new(name: 'Name')
-      expect(instance.name).to eq('Name')
-      expect(instance['name']).to eq('Name')
-      expect(instance[:name]).to eq('Name')
-      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Name">')
-      expect(instance.to_hash).to eq('name' => 'Name')
-    end
-  end
-
-  it 'updates' do
-    instance = DashWithIndifferentAccess.new
-    instance['name'] = 'Updated String'
-    expect(instance.name).to eq('Updated String')
-    instance[:name] = 'Updated Symbol'
-    expect(instance.name).to eq('Updated Symbol')
-    instance.name = 'Updated Method'
-    expect(instance.name).to eq('Updated Method')
-  end
-
-  context 'initialized with both prefers last assignment' do
-    it 'string, then symbol' do
-      instance = DashWithIndifferentAccess.new('name' => 'First', name: 'Last')
-      expect(instance.name).to eq('Last')
-      expect(instance['name']).to eq('Last')
-      expect(instance[:name]).to eq('Last')
-      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="Last">')
-      expect(instance.to_hash).to eq('name' => 'Last')
-    end
-
-    it 'symbol then string' do
-      instance = DashWithIndifferentAccess.new(name: 'Last', 'name' => 'First')
-      expect(instance.name).to eq('First')
-      expect(instance['name']).to eq('First')
-      expect(instance[:name]).to eq('First')
-      expect(instance.inspect).to eq('#<DashWithIndifferentAccess name="First">')
-      expect(instance.to_hash).to eq('name' => 'First')
-    end
-  end
-end

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,144 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/hash/indifferent_access'
-
-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
-
-    context 'when match value is hash itself' do
-      let(:hash) do
-        {
-          title: {
-            type: :string
-          },
-          library: {
-            books: [
-              { title: 'Call of the Wild' },
-              { title: 'Moby Dick' }
-            ],
-            shelves: nil,
-            location: {
-              address: '123 Library St.',
-              title: 'Main Library'
-            }
-          }
-        }
-      end
-
-      it 'detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title))
-          .to eq([{ type: :string }, 'Call of the Wild', 'Moby Dick', 'Main Library'])
-      end
-    end
-  end
-
-  context 'on an ActiveSupport::HashWithIndifferentAccess' do
-    subject(:instance) { hash.with_indifferent_access.extend(Hashie::Extensions::DeepFind) }
-
-    describe '#deep_find' do
-      it 'indifferently detects a value from a nested hash' do
-        expect(instance.deep_find(:address)).to eq('123 Library St.')
-        expect(instance.deep_find('address')).to eq('123 Library St.')
-      end
-
-      it 'indifferently detects a value from a nested array' do
-        expect(instance.deep_find(:title)).to eq('Call of the Wild')
-        expect(instance.deep_find('title')).to eq('Call of the Wild')
-      end
-
-      it 'indifferently returns nil if it does not find a match' do
-        expect(instance.deep_find(:wahoo)).to be_nil
-        expect(instance.deep_find('wahoo')).to be_nil
-      end
-    end
-
-    describe '#deep_find_all' do
-      it 'indifferently detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title))
-          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-        expect(instance.deep_find_all('title'))
-          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-      end
-
-      it 'indifferently returns nil if it does not find any matches' do
-        expect(instance.deep_find_all(:wahoo)).to be_nil
-        expect(instance.deep_find_all('wahoo')).to be_nil
-      end
-    end
-  end
-
-  context 'on a Hash including Hashie::Extensions::IndifferentAccess' do
-    let(:klass) { Class.new(Hash) { include Hashie::Extensions::IndifferentAccess } }
-    subject(:instance) { klass[hash.dup].extend(Hashie::Extensions::DeepFind) }
-
-    describe '#deep_find' do
-      it 'indifferently detects a value from a nested hash' do
-        expect(instance.deep_find(:address)).to eq('123 Library St.')
-        expect(instance.deep_find('address')).to eq('123 Library St.')
-      end
-
-      it 'indifferently detects a value from a nested array' do
-        expect(instance.deep_find(:title)).to eq('Call of the Wild')
-        expect(instance.deep_find('title')).to eq('Call of the Wild')
-      end
-
-      it 'indifferently returns nil if it does not find a match' do
-        expect(instance.deep_find(:wahoo)).to be_nil
-        expect(instance.deep_find('wahoo')).to be_nil
-      end
-    end
-
-    describe '#deep_find_all' do
-      it 'indifferently detects all values from a nested hash' do
-        expect(instance.deep_find_all(:title))
-          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-        expect(instance.deep_find_all('title'))
-          .to eq(['Call of the Wild', 'Moby Dick', 'Main Library'])
-      end
-
-      it 'indifferently returns nil if it does not find any matches' do
-        expect(instance.deep_find_all(:wahoo)).to be_nil
-        expect(instance.deep_find_all('wahoo')).to be_nil
-      end
-    end
-  end
-end

data/spec/hashie/extensions/deep_locate_spec.rb

@@ -1,138 +0,0 @@
-require 'spec_helper'
-require 'active_support/core_ext/hash/indifferent_access'
-
-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
-
-  context 'on an ActiveSupport::HashWithIndifferentAccess' do
-    let(:instance) { hash.dup.with_indifferent_access }
-
-    it 'can locate symbolic keys' do
-      expect(described_class.deep_locate(:lsr10, instance)).to eq ['lsr10' => { 'gte' => 2014 }]
-    end
-
-    it 'can locate string keys' do
-      expect(described_class.deep_locate('lsr10', instance)).to eq ['lsr10' => { 'gte' => 2014 }]
-    end
-  end
-end