hashie 4.0.0 → 4.1.0

data/spec/hashie/extensions/key_conversion_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-require 'support/module_context'
-
-describe Hashie::Extensions::KeyConversion do
-  include_context 'included hash module'
-
-  it { should respond_to(:stringify_keys) }
-  it { should respond_to(:stringify_keys!) }
-
-  it { should respond_to(:symbolize_keys) }
-  it { should respond_to(:symbolize_keys!) }
-end

data/spec/hashie/extensions/mash/define_accessors_spec.rb

@@ -1,90 +0,0 @@
-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/mash/keep_original_keys_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hashie::Extensions::Mash::KeepOriginalKeys do
-  let(:keeping_mash) do
-    Class.new(Hashie::Mash) do
-      include Hashie::Extensions::Mash::KeepOriginalKeys
-    end
-  end
-
-  it 'keeps the keys in the resulting hash identical to the original' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash.to_hash).to eq(original)
-  end
-
-  it 'indifferently responds to keys' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash['a']).to eq(mash[:a])
-    expect(mash['b']).to eq(mash[:b])
-  end
-
-  it 'responds to all method accessors like a Mash' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    expect(mash.a).to eq('apple')
-    expect(mash.a?).to eq(true)
-    expect(mash.b).to eq('bottle')
-    expect(mash.b?).to eq(true)
-    expect(mash.underbang_).to be_a(keeping_mash)
-    expect(mash.bang!).to be_a(keeping_mash)
-    expect(mash.predicate?).to eq(false)
-  end
-
-  it 'keeps the keys that are directly passed without converting them' do
-    original = { :a => 'apple', 'b' => 'bottle' }
-    mash = keeping_mash.new(original)
-
-    mash[:c] = 'cat'
-    mash['d'] = 'dog'
-    expect(mash.to_hash).to eq(:a => 'apple', 'b' => 'bottle', :c => 'cat', 'd' => 'dog')
-  end
-end

data/spec/hashie/extensions/mash/safe_assignment_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::Mash::SafeAssignment do
-  class MashWithSafeAssignment < Hashie::Mash
-    include Hashie::Extensions::Mash::SafeAssignment
-
-    private
-
-    def my_own_private
-      :hello!
-    end
-  end
-
-  context 'when included in Mash' do
-    subject { MashWithSafeAssignment.new }
-
-    context 'when not attempting to override a method' do
-      it 'assigns just fine' do
-        expect do
-          subject.blabla = 'Test'
-          subject.blabla = 'Test'
-        end.to_not raise_error
-      end
-    end
-
-    context 'when attempting to override a method' do
-      it 'raises an error' do
-        expect { subject.zip = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when attempting to override a private method' do
-      it 'raises an error' do
-        expect { subject.my_own_private = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when attempting to initialize with predefined method' do
-      it 'raises an error' do
-        expect { MashWithSafeAssignment.new(zip: true) }.to raise_error(ArgumentError)
-      end
-    end
-
-    context 'when setting as a hash key' do
-      it 'still raises if conflicts with a method' do
-        expect { subject[:zip] = 'Test' }.to raise_error(ArgumentError)
-      end
-    end
-  end
-end

data/spec/hashie/extensions/mash/symbolize_keys_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe Hashie::Extensions::Mash::SymbolizeKeys do
-  it 'raises an error when included in a class that is not a Mash' do
-    expect do
-      Class.new do
-        include Hashie::Extensions::Mash::SymbolizeKeys
-      end
-    end.to raise_error(ArgumentError)
-  end
-
-  it 'symbolizes all keys in the Mash' do
-    my_mash = Class.new(Hashie::Mash) do
-      include Hashie::Extensions::Mash::SymbolizeKeys
-    end
-
-    expect(my_mash.new('test' => 'value').to_h).to eq(test: 'value')
-  end
-
-  context 'implicit to_hash on double splat' do
-    let(:destructure) { ->(**opts) { opts } }
-    let(:my_mash) do
-      Class.new(Hashie::Mash) do
-        include Hashie::Extensions::Mash::SymbolizeKeys
-      end
-    end
-    let(:instance) { my_mash.new('outer' => { 'inner' => 42 }, 'testing' => [1, 2, 3]) }
-
-    subject { destructure.call(instance) }
-
-    it 'is converted on method calls' do
-      expect(subject).to eq(outer: { inner: 42 }, testing: [1, 2, 3])
-    end
-
-    it 'is converted on explicit operator call' do
-      expect(**instance).to eq(outer: { inner: 42 }, testing: [1, 2, 3])
-    end
-  end
-end

data/spec/hashie/extensions/merge_initializer_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::MergeInitializer do
-  class MergeInitializerHash < Hash
-    include Hashie::Extensions::MergeInitializer
-  end
-
-  subject { MergeInitializerHash }
-
-  it 'initializes with no arguments' do
-    expect(subject.new).to eq({})
-  end
-
-  it 'initializes with a hash' do
-    expect(subject.new(abc: 'def')).to eq(abc: 'def')
-  end
-
-  it 'initializes with a hash and a default' do
-    h = subject.new({ abc: 'def' }, 'bar')
-    expect(h[:foo]).to eq 'bar'
-    expect(h[:abc]).to eq 'def'
-  end
-end

data/spec/hashie/extensions/method_access_spec.rb

@@ -1,233 +0,0 @@
-require 'spec_helper'
-
-describe Hashie::Extensions::MethodReader do
-  class ReaderHash < Hash
-    include Hashie::Extensions::MethodReader
-
-    def initialize(hash = {})
-      update(hash)
-    end
-  end
-
-  subject { ReaderHash }
-
-  it 'reads string keys from the method' do
-    expect(subject.new('awesome' => 'sauce').awesome).to eq 'sauce'
-  end
-
-  it 'reads symbol keys from the method' do
-    expect(subject.new(awesome: 'sauce').awesome).to eq 'sauce'
-  end
-
-  it 'reads nil and false values out properly' do
-    h = subject.new(nil: nil, false: false) # rubocop:disable Lint/BooleanSymbol
-    expect(h.nil).to eq nil
-    expect(h.false).to eq false
-  end
-
-  it 'raises a NoMethodError for undefined keys' do
-    expect { subject.new.awesome }.to raise_error(NoMethodError)
-  end
-
-  it 'returns false for undefined keys if key with question has been called ' do
-    expect(subject.new.awesome?).to eq false
-  end
-
-  it 'returns true for defined keys if key with question has been called' do
-    expect(subject.new(awesome: 'sauce').awesome?).to eq true
-  end
-
-  describe '#respond_to?' do
-    it 'is true for string keys' do
-      expect(subject.new('awesome' => 'sauce')).to be_respond_to(:awesome)
-    end
-
-    it 'is true for symbol keys' do
-      expect(subject.new(awesome: 'sauce')).to be_respond_to(:awesome)
-    end
-
-    it 'is false for non-keys' do
-      expect(subject.new).not_to be_respond_to(:awesome)
-    end
-  end
-end
-
-describe Hashie::Extensions::MethodWriter do
-  class WriterHash < Hash
-    include Hashie::Extensions::MethodWriter
-  end
-
-  subject { WriterHash.new }
-
-  it 'writes from a method call' do
-    subject.awesome = 'sauce'
-    expect(subject['awesome']).to eq 'sauce'
-  end
-
-  it 'converts the key using the #convert_key method' do
-    allow(subject).to receive(:convert_key).and_return(:awesome)
-    subject.awesome = 'sauce'
-    expect(subject[:awesome]).to eq 'sauce'
-  end
-
-  it 'raises NoMethodError on non equals-ending methods' do
-    expect { subject.awesome }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to? correctly' do
-    expect(subject).to be_respond_to(:abc=)
-    expect(subject).not_to be_respond_to(:abc)
-  end
-end
-
-describe Hashie::Extensions::MethodQuery do
-  class QueryHash < Hash
-    include Hashie::Extensions::MethodQuery
-
-    def initialize(hash = {})
-      update(hash)
-    end
-  end
-
-  subject { QueryHash }
-
-  it 'is true for non-nil string key values' do
-    expect(subject.new('abc' => 123).abc?).to eq true
-  end
-
-  it 'is true for non-nil symbol key values' do
-    expect(subject.new(abc: 123).abc?).to eq true
-  end
-
-  it 'is false for false key values' do
-    expect(subject.new(abc: false).abc?).to eq false
-  end
-
-  it 'is false for nil key values' do
-    expect(subject.new(abc: nil).abc?).to eq false
-  end
-
-  it 'raises a NoMethodError for non-set keys' do
-    expect { subject.new.abc? }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to? for existing string keys' do
-    expect(subject.new('abc' => 'def')).to be_respond_to('abc?')
-  end
-
-  it '#respond_to? for existing symbol keys' do
-    expect(subject.new(abc: 'def')).to be_respond_to(:abc?)
-  end
-
-  it 'does not #respond_to? for non-existent keys' do
-    expect(subject.new).not_to be_respond_to('abc?')
-  end
-end
-
-describe Hashie::Extensions::MethodAccess do
-  it 'includes all of the other method mixins' do
-    klass = Class.new(Hash)
-    klass.send :include, Hashie::Extensions::MethodAccess
-
-    included_modules = klass.ancestors & [
-      Hashie::Extensions::MethodReader,
-      Hashie::Extensions::MethodWriter,
-      Hashie::Extensions::MethodQuery
-    ]
-
-    expect(included_modules.size).to eq 3
-  end
-end
-
-describe Hashie::Extensions::MethodOverridingWriter do
-  class OverridingHash < Hash
-    include Hashie::Extensions::MethodOverridingWriter
-  end
-
-  subject { OverridingHash.new }
-
-  it 'writes from a method call' do
-    subject.awesome = 'sauce'
-    expect(subject['awesome']).to eq 'sauce'
-  end
-
-  it 'convertes the key using the #convert_key method' do
-    allow(subject).to receive(:convert_key).and_return(:awesome)
-    subject.awesome = 'sauce'
-    expect(subject[:awesome]).to eq 'sauce'
-  end
-
-  it 'raises NoMethodError on non equals-ending methods' do
-    expect { subject.awesome }.to raise_error(NoMethodError)
-  end
-
-  it '#respond_to_missing? correctly' do
-    expect(subject).to respond_to(:abc=)
-    expect(subject).not_to respond_to(:abc)
-    expect(subject.method(:abc=)).not_to be_nil
-  end
-
-  context 'when writing a Hash method' do
-    before { subject.zip = 'a-dee-doo-dah' }
-
-    it 'overrides the original method' do
-      expect(subject.zip).to eq 'a-dee-doo-dah'
-    end
-
-    it 'aliases the method with two leading underscores' do
-      expect(subject.__zip).to eq [[%w[zip a-dee-doo-dah]]]
-    end
-
-    it 'does not re-alias when overriding an already overridden method' do
-      subject.zip = 'test'
-      expect(subject.zip).to eq 'test'
-      expect(subject.__zip).to eq [[%w[zip test]]]
-    end
-  end
-end
-
-describe Hashie::Extensions::MethodAccessWithOverride do
-  it 'includes all of the other method mixins' do
-    mod_list = [
-      Hashie::Extensions::MethodReader,
-      Hashie::Extensions::MethodOverridingWriter,
-      Hashie::Extensions::MethodQuery,
-      Hashie::Extensions::MethodOverridingInitializer
-    ]
-
-    klass = Class.new(Hash)
-    klass.send :include, Hashie::Extensions::MethodAccessWithOverride
-
-    expect((klass.ancestors & mod_list).size).to eq 4
-  end
-end
-
-describe Hashie::Extensions::MethodOverridingInitializer do
-  class OverridingHash < Hash
-    include Hashie::Extensions::MethodOverridingInitializer
-  end
-
-  context 'when the key is a string' do
-    subject { OverridingHash.new('zip' => 'a-dee-doo-dah') }
-
-    it 'overrides the original method' do
-      expect(subject.zip).to eq 'a-dee-doo-dah'
-    end
-
-    it 'aliases the method with two leading underscores' do
-      expect(subject.__zip).to eq [[%w[zip a-dee-doo-dah]]]
-    end
-  end
-
-  context 'when the key is a symbol' do
-    subject { OverridingHash.new(zip: 'a-dee-doo-dah') }
-
-    it 'overrides the original method' do
-      expect(subject.zip).to eq 'a-dee-doo-dah'
-    end
-
-    it 'aliases the method with two leading underscores' do
-      expect(subject.__zip).to eq [[%w[zip a-dee-doo-dah]]]
-    end
-  end
-end