hashie 3.6.0 → 4.0.0

data/spec/hashie/extensions/ignore_undeclared_spec.rb

@@ -41,7 +41,8 @@ describe Hashie::Extensions::IgnoreUndeclared do
         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)
+      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/mash/define_accessors_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Hashie::Extensions::Mash::DefineAccessors do
+  let(:args) { [] }
+
+  shared_examples 'class with dynamically defined accessors' do
+    it 'defines reader on demand' do
+      expect(subject.method_defined?(:foo)).to be_falsey
+      instance.foo
+      expect(subject.method_defined?(:foo)).to be_truthy
+    end
+
+    it 'defines writer on demand' do
+      expect(subject.method_defined?(:foo=)).to be_falsey
+      instance.foo = :bar
+      expect(subject.method_defined?(:foo=)).to be_truthy
+    end
+
+    it 'defines predicate on demand' do
+      expect(subject.method_defined?(:foo?)).to be_falsey
+      instance.foo?
+      expect(subject.method_defined?(:foo?)).to be_truthy
+    end
+
+    it 'defines initializing reader on demand' do
+      expect(subject.method_defined?(:foo!)).to be_falsey
+      instance.foo!
+      expect(subject.method_defined?(:foo!)).to be_truthy
+    end
+
+    it 'defines underbang reader on demand' do
+      expect(subject.method_defined?(:foo_)).to be_falsey
+      instance.foo_
+      expect(subject.method_defined?(:foo_)).to be_truthy
+    end
+
+    context 'when initializing from another hash' do
+      let(:args) { [{ foo: :bar }] }
+
+      it 'does not define any accessors' do
+        expect(subject.method_defined?(:foo)).to be_falsey
+        expect(subject.method_defined?(:foo=)).to be_falsey
+        expect(subject.method_defined?(:foo?)).to be_falsey
+        expect(subject.method_defined?(:foo!)).to be_falsey
+        expect(subject.method_defined?(:foo_)).to be_falsey
+        expect(instance.foo).to eq :bar
+      end
+    end
+  end
+
+  context 'when included in Mash subclass' do
+    subject { Class.new(Hashie::Mash) { include Hashie::Extensions::Mash::DefineAccessors } }
+    let(:instance) { subject.new(*args) }
+
+    describe 'this subclass' do
+      it_behaves_like 'class with dynamically defined accessors'
+
+      describe 'when accessors are overrided in class' do
+        before do
+          subject.class_eval do
+            def foo
+              if self[:foo] != 1
+                :bar
+              else
+                super
+              end
+            end
+          end
+        end
+
+        it 'allows to call super' do
+          expect(instance.foo).to eq :bar
+          instance.foo = 2
+          expect(instance.foo).to eq :bar
+          instance.foo = 1
+          expect(instance.foo).to eq 1
+        end
+      end
+    end
+  end
+
+  context 'when Mash instance is extended' do
+    let(:instance) { Hashie::Mash.new(*args).with_accessors! }
+    subject { instance.singleton_class }
+
+    describe 'its singleton class' do
+      it_behaves_like 'class with dynamically defined accessors'
+    end
+  end
+end

data/spec/hashie/extensions/method_access_spec.rb

@@ -128,7 +128,14 @@ 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
+
+    included_modules = klass.ancestors & [
+      Hashie::Extensions::MethodReader,
+      Hashie::Extensions::MethodWriter,
+      Hashie::Extensions::MethodQuery
+    ]
+
+    expect(included_modules.size).to eq 3
   end
 end
 

data/spec/hashie/extensions/strict_key_access_spec.rb

@@ -35,34 +35,33 @@ describe Hashie::Extensions::StrictKeyAccess do
     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})
+        expect { instance.key(invalid_value) }.to raise_error KeyError
       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'
+        expect { instance.default(invalid_key) }
+          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
       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'
+        expect { instance.default = invalid_key }
+          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
       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'
+        expect { instance.default_proc }
+          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
       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'
+        expect { instance.default_proc = proc {} }
+          .to raise_error Hashie::Extensions::StrictKeyAccess::DefaultError
       end
     end
   end

data/spec/hashie/extensions/symbolize_keys_spec.rb

@@ -88,7 +88,9 @@ describe Hashie::Extensions::SymbolizeKeys do
 
   context 'singleton methods' do
     subject { Hash }
-    let(:object) { subject.new.merge('a' => 1, 'b' => { 'c' => 2 }).extend(Hashie::Extensions::SymbolizeKeys) }
+    let(:object) do
+      subject.new.merge('a' => 1, 'b' => { 'c' => 2 }).extend(Hashie::Extensions::SymbolizeKeys)
+    end
     let(:expected_hash) { { a: 1, b: { c: 2 } } }
 
     describe '.symbolize_keys' do

data/spec/hashie/hash_spec.rb

@@ -64,21 +64,60 @@ describe Hash do
     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]
+      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] })
+
+      expected = {
+        'a' => 'hey',
+        123 => 'bob',
+        'array' => [1, 2, 3],
+        subhash: { 'a' => 'hey', b: 'bar', 123 => 'bob', 'array' => [1, 2, 3] }
+      }
+
+      expect(stringified_hash).to eq(expected)
     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]
+      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] })
+
+      expected = {
+        'a' => 'hey',
+        '123' => 'bob',
+        'array' => [1, 2, 3],
+        'subhash' => { 'a' => 'hey', 'b' => 'bar', '123' => 'bob', 'array' => [1, 2, 3] }
+      }
+
+      expect(symbolized_hash).to eq(expected)
     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]
+      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] })
+
+      expected = {
+        a: 'hey',
+        :"123" => 'bob',
+        array: [1, 2, 3],
+        subhash: { a: 'hey', b: 'bar', :'123' => 'bob', array: [1, 2, 3] }
+      }
+
+      expect(symbolized_hash).to eq(expected)
     end
   end
 end

data/spec/hashie/mash_spec.rb

@@ -154,14 +154,15 @@ describe Hashie::Mash do
       mash_class = Class.new(Hashie::Mash) do
         disable_warnings
       end
-
       mash_class.new('trust' => { 'two' => 2 })
 
       expect(logger_output).to be_blank
     end
 
     it 'cannot disable logging on the base Mash' do
-      expect { Hashie::Mash.disable_warnings }.to raise_error(Hashie::Mash::CannotDisableMashWarnings)
+      expected_error = Hashie::Extensions::KeyConflictWarning::CannotDisableMashWarnings
+
+      expect { Hashie::Mash.disable_warnings }.to raise_error(expected_error)
     end
 
     it 'carries over the disable for warnings on grandchild classes' do
@@ -174,6 +175,78 @@ describe Hashie::Mash do
 
       expect(logger_output).to be_blank
     end
+
+    it 'writes to logger when a key is overridden that is not ignored' do
+      mash_class = Class.new(Hashie::Mash) do
+        disable_warnings :merge
+      end
+
+      mash_class.new('address' => { 'zip' => '90210' })
+      expect(logger_output).not_to be_blank
+    end
+
+    it 'does not write to logger when a key is overridden that is ignored' do
+      mash_class = Class.new(Hashie::Mash) do
+        disable_warnings :zip
+      end
+
+      mash_class.new('address' => { 'zip' => '90210' })
+      expect(logger_output).to be_blank
+    end
+
+    it 'carries over the ignored warnings list for warnings on grandchild classes' do
+      child_class = Class.new(Hashie::Mash) do
+        disable_warnings :zip, :merge
+      end
+      grandchild_class = Class.new(child_class)
+
+      grandchild_class.new('address' => { 'zip' => '90210' }, 'merge' => true)
+
+      expect(grandchild_class.disabled_warnings).to eq(%i[zip merge])
+      expect(logger_output).to be_blank
+    end
+
+    context 'multiple disable_warnings calls' do
+      context 'calling disable_warnings multiple times with parameters' do
+        it 'appends each new parameter to the ignore list' do
+          child_class = Class.new(Hashie::Mash) do
+            disable_warnings :zip
+            disable_warnings :merge
+            disable_warnings :cycle
+          end
+
+          expect(child_class.disabled_warnings).to eq(%i[zip merge cycle])
+        end
+      end
+
+      context 'calling disable_warnings without keys after calling with keys' do
+        it 'uses the last call to determine the ignore list' do
+          child_class = Class.new(Hashie::Mash) do
+            disable_warnings :zip
+            disable_warnings
+          end
+
+          child_class.new('address' => { 'zip' => '90210' }, 'merge' => true, 'cycle' => 'bi')
+
+          expect(child_class.disabled_warnings).to eq([])
+          expect(logger_output).to be_blank
+        end
+      end
+
+      context 'calling disable_parameters with keys after calling without keys' do
+        it 'only ignores logging for ignored methods' do
+          child_class = Class.new(Hashie::Mash) do
+            disable_warnings
+            disable_warnings :zip
+          end
+
+          child_class.new('address' => { 'zip' => '90210' }, 'merge' => true)
+
+          expect(logger_output).to match(/#{child_class}#merge/)
+          expect(logger_output).not_to match(/#{child_class}#zip/)
+        end
+      end
+    end
   end
 
   context 'updating' do
@@ -229,15 +302,29 @@ describe Hashie::Mash do
 
       # http://www.ruby-doc.org/core-1.9.3/Hash.html#method-i-update
       it 'accepts a block' do
-        duped = subject.merge(details: { address: 'Pasadena CA' }) { |_, oldv, newv| [oldv, newv].join(', ') }
+        duped = subject.merge(details: { address: 'Pasadena CA' }) do |_, oldv, newv|
+          [oldv, newv].join(', ')
+        end
+
         expect(duped.details.address).to eq 'Nowhere road, Pasadena CA'
       end
 
       it 'copies values for non-duplicate keys when a block is supplied' do
-        duped = subject.merge(details: { address: 'Pasadena CA', state: 'West Thoughtleby' }) { |_, oldv, _| oldv }
+        m_hash = { details: { address: 'Pasadena CA', state: 'West Thoughtleby' } }
+        duped = subject.merge(m_hash) { |_, oldv, _| oldv }
+
         expect(duped.details.address).to eq 'Nowhere road'
         expect(duped.details.state).to eq 'West Thoughtleby'
       end
+
+      it 'does not raise an exception when default_proc raises an error' do
+        hash = described_class.new(a: 1) { |_k, _v| raise('Should not be raise I') }
+        other_has = described_class.new(a: 2, b: 2) { |_k, _v| raise('Should not be raise II') }
+        expected_hash = described_class.new(a: 2, b: 2)
+
+        res = hash.merge(other_has)
+        expect(res).to eq(expected_hash)
+      end
     end
 
     describe 'shallow update' do
@@ -633,7 +720,7 @@ describe Hashie::Mash do
     context 'if the file exists' do
       before do
         expect(File).to receive(:file?).with(path).and_return(true)
-        expect(parser).to receive(:perform).with(path).and_return(config)
+        expect(parser).to receive(:perform).with(path, {}).and_return(config)
       end
 
       it { is_expected.to be_a(Hashie::Mash) }
@@ -665,7 +752,7 @@ describe Hashie::Mash do
 
       before do
         expect(File).to receive(:file?).with(path).and_return(true)
-        expect(parser).to receive(:perform).with(path).and_return(config)
+        expect(parser).to receive(:perform).with(path, {}).and_return(config)
       end
 
       it 'return a Mash from a file' do
@@ -681,8 +768,8 @@ describe Hashie::Mash do
       before do
         expect(File).to receive(:file?).with(path).and_return(true)
         expect(File).to receive(:file?).with("#{path}+1").and_return(true)
-        expect(parser).to receive(:perform).once.with(path).and_return(config)
-        expect(parser).to receive(:perform).once.with("#{path}+1").and_return(config)
+        expect(parser).to receive(:perform).once.with(path, {}).and_return(config)
+        expect(parser).to receive(:perform).once.with("#{path}+1", {}).and_return(config)
       end
 
       it 'cache the loaded yml file', :test_cache do
@@ -694,6 +781,50 @@ describe Hashie::Mash do
         expect(subject.object_id).to eq subject.object_id
       end
     end
+
+    context 'when the file has aliases in it' do
+      it 'can use the aliases and does not raise an error' do
+        mash = Hashie::Mash.load('spec/fixtures/yaml_with_aliases.yml')
+        expect(mash.company_a.accounts.admin.password).to eq('secret')
+      end
+      it 'can override the value of aliases' do
+        expect do
+          Hashie::Mash.load('spec/fixtures/yaml_with_aliases.yml', aliases: false)
+        end.to raise_error Psych::BadAlias, /base_accounts/
+      end
+    end
+
+    context 'when the file has symbols' do
+      it 'can override the value of permitted_classes' do
+        mash = Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml', permitted_classes: [Symbol])
+        expect(mash.user_icon.width).to eq(200)
+      end
+      it 'uses defaults for permitted_classes' do
+        expect do
+          Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml')
+        end.to raise_error Psych::DisallowedClass, /Symbol/
+      end
+      it 'can override the value of permitted_symbols' do
+        mash = Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml',
+                                 permitted_classes: [Symbol],
+                                 permitted_symbols: %i[
+                                   user_icon
+                                   width
+                                   height
+                                 ])
+        expect(mash.user_icon.width).to eq(200)
+      end
+      it 'raises an error on insufficient permitted_symbols' do
+        expect do
+          Hashie::Mash.load('spec/fixtures/yaml_with_symbols.yml',
+                            permitted_classes: [Symbol],
+                            permitted_symbols: %i[
+                              user_icon
+                              width
+                            ])
+        end.to raise_error Psych::DisallowedClass, /Symbol/
+      end
+    end
   end
 
   describe '#to_module(mash_method_name)' do
@@ -751,6 +882,103 @@ describe Hashie::Mash do
     end
   end
 
+  describe '#compact' do
+    subject(:mash) { described_class.new(a: 1, b: nil) }
+
+    it 'returns a Hashie::Mash' do
+      expect(mash.compact).to be_kind_of(described_class)
+    end
+
+    it 'removes keys with nil values' do
+      expect(mash.compact).to eq('a' => 1)
+    end
+
+    context 'when using with subclass' do
+      let(:subclass) { Class.new(Hashie::Mash) }
+      subject(:sub_mash) { subclass.new(a: 1, b: nil) }
+
+      it 'creates an instance of subclass' do
+        expect(sub_mash.compact).to be_kind_of(subclass)
+      end
+    end
+  end
+
+  describe '#invert' do
+    subject(:mash) { described_class.new(a: 'apple', b: 4) }
+
+    it 'returns a Hashie::Mash' do
+      expect(mash.invert).to be_kind_of(described_class)
+    end
+
+    it 'returns a mash with the keys and values inverted' do
+      expect(mash.invert).to eq('apple' => 'a', '4' => 'b')
+    end
+
+    context 'when using with subclass' do
+      let(:subclass) { Class.new(Hashie::Mash) }
+      subject(:sub_mash) { subclass.new(a: 1, b: nil) }
+
+      it 'creates an instance of subclass' do
+        expect(sub_mash.invert).to be_kind_of(subclass)
+      end
+    end
+  end
+
+  describe '#reject' do
+    subject(:mash) { described_class.new(a: 1, b: nil) }
+
+    it 'returns a Hashie::Mash' do
+      expect(mash.reject { |_k, v| v.nil? }).to be_kind_of(described_class)
+    end
+
+    it 'rejects keys for which the block returns true' do
+      expect(mash.reject { |_k, v| v.nil? }).to eq('a' => 1)
+    end
+
+    context 'when using with subclass' do
+      let(:subclass) { Class.new(Hashie::Mash) }
+      subject(:sub_mash) { subclass.new(a: 1, b: nil) }
+
+      it 'creates an instance of subclass' do
+        expect(sub_mash.reject { |_k, v| v.nil? }).to be_kind_of(subclass)
+      end
+    end
+  end
+
+  describe '#select' do
+    subject(:mash) { described_class.new(a: 'apple', b: 4) }
+
+    it 'returns a Hashie::Mash' do
+      expect(mash.select { |_k, v| v.is_a? String }).to be_kind_of(described_class)
+    end
+
+    it 'selects keys for which the block returns true' do
+      expect(mash.select { |_k, v| v.is_a? String }).to eq('a' => 'apple')
+    end
+
+    context 'when using with subclass' do
+      let(:subclass) { Class.new(Hashie::Mash) }
+      subject(:sub_mash) { subclass.new(a: 1, b: nil) }
+
+      it 'creates an instance of subclass' do
+        expect(sub_mash.select { |_k, v| v.is_a? String }).to be_kind_of(subclass)
+      end
+    end
+  end
+
+  describe '.quiet' do
+    it 'returns a subclass of the calling class' do
+      expect(Hashie::Mash.quiet.new).to be_a(Hashie::Mash)
+    end
+
+    it 'memoizes and returns classes' do
+      call_one = Hashie::Mash.quiet
+      call_two = Hashie::Mash.quiet
+      expect(Hashie::Mash.instance_variable_get('@memoized_classes').count).to eq(1)
+      expect(call_one).to eq(call_two)
+    end
+  end
+
   with_minimum_ruby('2.3.0') do
     describe '#dig' do
       subject { described_class.new(a: { b: 1 }) }
@@ -768,4 +996,82 @@ describe Hashie::Mash do
       end
     end
   end
+
+  with_minimum_ruby('2.4.0') do
+    describe '#transform_values' do
+      subject(:mash) { described_class.new(a: 1) }
+
+      it 'returns a Hashie::Mash' do
+        expect(mash.transform_values(&:to_s)).to be_kind_of(described_class)
+      end
+
+      it 'transforms the value' do
+        expect(mash.transform_values(&:to_s).a).to eql('1')
+      end
+
+      context 'when using with subclass' do
+        let(:subclass) { Class.new(Hashie::Mash) }
+        subject(:sub_mash) { subclass.new(a: 1).transform_values { |a| a + 2 } }
+
+        it 'creates an instance of subclass' do
+          expect(sub_mash).to be_kind_of(subclass)
+        end
+      end
+    end
+  end
+
+  with_minimum_ruby('2.5.0') do
+    describe '#slice' do
+      subject(:mash) { described_class.new(a: 1, b: 2) }
+
+      it 'returns a Hashie::Mash' do
+        expect(mash.slice(:a)).to be_kind_of(described_class)
+      end
+
+      it 'returns a Mash with only the keys passed' do
+        expect(mash.slice(:a).to_hash).to eq('a' => 1)
+      end
+
+      context 'when using with subclass' do
+        let(:subclass) { Class.new(Hashie::Mash) }
+        subject(:sub_mash) { subclass.new(a: 1, b: 2) }
+
+        it 'creates an instance of subclass' do
+          expect(sub_mash.slice(:a)).to be_kind_of(subclass)
+        end
+      end
+    end
+
+    describe '#transform_keys' do
+      subject(:mash) { described_class.new(a: 1, b: 2) }
+
+      it 'returns a Hashie::Mash' do
+        expect(mash.transform_keys { |k| k + k }).to be_kind_of(described_class)
+      end
+
+      it 'returns a Mash with transformed keys' do
+        expect(mash.transform_keys { |k| k + k }).to eq('aa' => 1, 'bb' => 2)
+      end
+
+      context 'when using with subclass' do
+        let(:subclass) { Class.new(Hashie::Mash) }
+        subject(:sub_mash) { subclass.new(a: 1, b: 2) }
+
+        it 'creates an instance of subclass' do
+          expect(sub_mash.transform_keys { |k| k + k }).to be_kind_of(subclass)
+        end
+      end
+    end
+  end
+
+  with_minimum_ruby('2.6.0') do
+    context 'ruby 2.6 merging' do
+      subject(:mash) { Hashie::Mash.new(model: 'Honda') }
+      it 'merges multiple hashes and mashes passeed to #merge' do
+        first_hash = { model: 'Ford' }
+        second_hash = { model: 'DeLorean' }
+        expect(mash.merge(first_hash, second_hash)).to eq('model' => 'DeLorean')
+      end
+    end
+  end
 end