hashie 3.5.7 → 5.0.0

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,138 +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,137 +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

data/spec/hashie/extensions/deep_merge_spec.rb

@@ -1,70 +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' } }, e: { e1: 1 } } }
-    let(:expected_hash) { { a: 1, a1: 1, b: 'b', c: { c1: 2, c2: 'c2', c3: { d1: 'd1', d2: 'd2' } }, e: { e1: 1 } } }
-
-    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
-
-    it 'merges new nested hash entries by value, not by reference' do
-      h1.deep_merge!(h2)
-      expect { h1[:e][:e1] = 'changed' }.not_to change { h2[:e][:e1] }
-    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
-
-  context 'from extended object' do
-    subject { Hash }
-    let(:h1) { subject.new.merge(a: 100, c: { c1: 100 }).extend(Hashie::Extensions::DeepMerge) }
-    let(:h2) { { b: 250, c: { c1: 200 } } }
-    let(:expected_hash) { { a: 100, b: 250, c: { c1: 200 } } }
-
-    it 'does not raise error' do
-      expect { h1.deep_merge(h2) } .not_to raise_error
-    end
-
-    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
-end

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -1,47 +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
-      property :str_state, from: 'str_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('str_provence' => 'Ontario').str_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