hashie 3.2.0 → 3.3.1

data/lib/hashie/version.rb

@@ -1,3 +1,3 @@
 module Hashie
-  VERSION = '3.2.0'
+  VERSION = '3.3.1'
 end

data/spec/hashie/extensions/coercion_spec.rb

@@ -1,16 +1,20 @@
 require 'spec_helper'
 
 describe Hashie::Extensions::Coercion do
+  class NotInitializable
+    private_class_method :new
+  end
+
   class Initializable
     attr_reader :coerced, :value
 
-    def initialize(obj, coerced = false)
+    def initialize(obj, coerced = nil)
       @coerced = coerced
       @value = obj.class.to_s
     end
 
     def coerced?
-      !!@coerced
+      !@coerced.nil?
     end
   end
 
@@ -32,6 +36,84 @@ describe Hashie::Extensions::Coercion do
   let(:instance) { subject.new }
 
   describe '#coerce_key' do
+    context 'nesting' do
+      class BaseCoercableHash < Hash
+        include Hashie::Extensions::Coercion
+        include Hashie::Extensions::MergeInitializer
+      end
+
+      class NestedCoercableHash < BaseCoercableHash
+        coerce_key :foo, String
+        coerce_key :bar, Integer
+      end
+
+      class RootCoercableHash < BaseCoercableHash
+        coerce_key :nested, NestedCoercableHash
+        coerce_key :nested_list, Array[NestedCoercableHash]
+        coerce_key :nested_hash, Hash[String => NestedCoercableHash]
+      end
+
+      def test_nested_object(obj)
+        expect(obj).to be_a(NestedCoercableHash)
+        expect(obj[:foo]).to be_a(String)
+        expect(obj[:bar]).to be_an(Integer)
+      end
+
+      subject { RootCoercableHash }
+      let(:instance) { subject.new }
+
+      it 'coerces nested objects' do
+        instance[:nested] = { foo: 123, bar: '456' }
+        test_nested_object(instance[:nested])
+      end
+
+      it 'coerces nested arrays' do
+        instance[:nested_list] = [
+          { foo: 123, bar: '456' },
+          { foo: 234, bar: '567' },
+          { foo: 345, bar: '678' }
+        ]
+        expect(instance[:nested_list]).to be_a Array
+        expect(instance[:nested_list].size).to eq(3)
+        instance[:nested_list].each do | nested |
+          test_nested_object nested
+        end
+      end
+
+      it 'coerces nested hashes' do
+        instance[:nested_hash] = {
+          a: { foo: 123, bar: '456' },
+          b: { foo: 234, bar: '567' },
+          c: { foo: 345, bar: '678' }
+        }
+        expect(instance[:nested_hash]).to be_a Hash
+        expect(instance[:nested_hash].size).to eq(3)
+        instance[:nested_hash].each do | key, nested |
+          expect(key).to be_a(String)
+          test_nested_object nested
+        end
+      end
+
+      context 'when repetitively including the module' do
+        class RepetitiveCoercableHash < NestedCoercableHash
+          include Hashie::Extensions::Coercion
+          include Hashie::Extensions::MergeInitializer
+
+          coerce_key :nested, NestedCoercableHash
+        end
+
+        subject { RepetitiveCoercableHash }
+        let(:instance) { subject.new }
+
+        it 'does not raise a stack overflow error' do
+          expect do
+            instance[:nested] = { foo: 123, bar: '456' }
+            test_nested_object(instance[:nested])
+          end.not_to raise_error
+        end
+      end
+    end
+
     it { expect(subject).to be_respond_to(:coerce_key) }
 
     it 'runs through coerce on a specified key' do
@@ -41,6 +123,13 @@ describe Hashie::Extensions::Coercion do
       expect(instance[:foo]).to be_coerced
     end
 
+    it 'skips unnecessary coercions' do
+      subject.coerce_key :foo, Coercable
+
+      instance[:foo] = Coercable.new('bar')
+      expect(instance[:foo]).to_not be_coerced
+    end
+
     it 'supports an array of keys' do
       subject.coerce_keys :foo, :bar, Coercable
 
@@ -92,6 +181,116 @@ describe Hashie::Extensions::Coercion do
       expect(instance[:foo].keys).to all(be_coerced)
     end
 
+    context 'coercing core types' do
+      def test_coercion(literal, target_type, coerce_method)
+        subject.coerce_key :foo, target_type
+        instance[:foo] = literal
+        expect(instance[:foo]).to be_a(target_type)
+        expect(instance[:foo]).to eq(literal.send(coerce_method))
+      end
+
+      RSpec.shared_examples 'coerces from numeric types' do |target_type, coerce_method|
+        it "coerces from String to #{target_type} via #{coerce_method}" do
+          test_coercion '2.0', target_type, coerce_method
+        end
+
+        it "coerces from Integer to #{target_type} via #{coerce_method}" do
+          # Fixnum
+          test_coercion 2, target_type, coerce_method
+          # Bignum
+          test_coercion 12_345_667_890_987_654_321, target_type, coerce_method
+        end
+
+        it "coerces from Rational to #{target_type} via #{coerce_method}" do
+          test_coercion Rational(2, 3), target_type, coerce_method
+        end
+      end
+
+      RSpec.shared_examples 'coerces from alphabetical types' do |target_type, coerce_method|
+        it "coerces from String to #{target_type} via #{coerce_method}" do
+          test_coercion 'abc', target_type, coerce_method
+        end
+
+        it "coerces from Symbol to #{target_type} via #{coerce_method}" do
+          test_coercion :abc, target_type, coerce_method
+        end
+      end
+
+      include_examples 'coerces from numeric types', Integer, :to_i
+      include_examples 'coerces from numeric types', Float, :to_f
+      include_examples 'coerces from numeric types', String, :to_s
+
+      include_examples 'coerces from alphabetical types', String, :to_s
+      include_examples 'coerces from alphabetical types', Symbol, :to_sym
+
+      it 'can coerce String to Rational when possible' do
+        test_coercion '2/3', Rational, :to_r
+      end
+
+      it 'can coerce String to Complex when possible' do
+        test_coercion '2/3+3/4i', Complex, :to_c
+      end
+
+      it 'coerces collections with core types' do
+        subject.coerce_key :foo, Hash[String => String]
+
+        instance[:foo] = {
+          abc: 123,
+          xyz: 987
+        }
+        expect(instance[:foo]).to eq(
+                                       'abc' => '123',
+                                       'xyz' => '987'
+                                     )
+      end
+
+      it 'can coerce via a proc' do
+        subject.coerce_key(:foo, lambda do |v|
+          case v
+          when String
+            return !!(v =~ /^(true|t|yes|y|1)$/i)
+          when Numeric
+            return !v.to_i.zero?
+          else
+            return v == true
+          end
+        end)
+
+        true_values = [true, 'true', 't', 'yes', 'y', '1', 1, -1]
+        false_values = [false, 'false', 'f', 'no', 'n', '0', 0]
+
+        true_values.each do |v|
+          instance[:foo] = v
+          expect(instance[:foo]).to be_a(TrueClass)
+        end
+        false_values.each do |v|
+          instance[:foo] = v
+          expect(instance[:foo]).to be_a(FalseClass)
+        end
+      end
+
+      it 'raises errors for non-coercable types' do
+        subject.coerce_key :foo, NotInitializable
+        expect { instance[:foo] = 'true' }.to raise_error(Hashie::CoercionError, /NotInitializable is not a coercable type/)
+      end
+
+      it 'can coerce false' do
+        subject.coerce_key :foo, Coercable
+
+        instance[:foo] = false
+        expect(instance[:foo]).to be_coerced
+        expect(instance[:foo].value).to eq('FalseClass')
+      end
+
+      it 'does not coerce nil' do
+        subject.coerce_key :foo, String
+
+        instance[:foo] = nil
+        expect(instance[:foo]).to_not eq('')
+        expect(instance[:foo]).to be_nil
+      end
+    end
+
     it 'calls #new if no coerce method is available' do
       subject.coerce_key :foo, Initializable
 
@@ -239,6 +438,91 @@ describe Hashie::Extensions::Coercion do
         expect(instance[:foo]).to be_kind_of(Coercable)
       end
     end
+
+    context 'core types' do
+      it 'coerces String to Integer when possible' do
+        subject.coerce_value String, Integer
+
+        instance[:foo] = '2'
+        instance[:bar] = '2.7'
+        instance[:hi] = 'hi'
+        expect(instance[:foo]).to be_a(Integer)
+        expect(instance[:foo]).to eq(2)
+        expect(instance[:bar]).to be_a(Integer)
+        expect(instance[:bar]).to eq(2)
+        expect(instance[:hi]).to be_a(Integer)
+        expect(instance[:hi]).to eq(0) # not what I expected...
+      end
+
+      it 'coerces non-numeric from String to Integer' do
+        # This was surprising, but I guess it's "correct"
+        # unless there is a stricter `to_i` alternative
+        subject.coerce_value String, Integer
+        instance[:hi] = 'hi'
+        expect(instance[:hi]).to be_a(Integer)
+        expect(instance[:hi]).to eq(0)
+      end
+
+      it 'raises a CoercionError when coercion is not possible' do
+        subject.coerce_value Fixnum, Symbol
+        expect { instance[:hi] = 1 }.to raise_error(Hashie::CoercionError, /Cannot coerce property :hi from Fixnum to Symbol/)
+      end
+
+      it 'coerces Integer to String' do
+        subject.coerce_value Integer, String
+
+        {
+          fixnum: 2,
+          bignum: 12_345_667_890_987_654_321,
+          float: 2.7,
+          rational: Rational(2, 3),
+          complex: Complex(1)
+        }.each do | k, v |
+          instance[k] = v
+          if v.is_a? Integer
+            expect(instance[k]).to be_a(String)
+            expect(instance[k]).to eq(v.to_s)
+          else
+            expect(instance[k]).to_not be_a(String)
+            expect(instance[k]).to eq(v)
+          end
+        end
+      end
+
+      it 'coerces Numeric to String' do
+        subject.coerce_value Numeric, String
+
+        {
+          fixnum: 2,
+          bignum: 12_345_667_890_987_654_321,
+          float: 2.7,
+          rational: Rational(2, 3),
+          complex: Complex(1)
+        }.each do | k, v |
+          instance[k] = v
+          expect(instance[k]).to be_a(String)
+          expect(instance[k]).to eq(v.to_s)
+        end
+      end
+
+      it 'can coerce via a proc' do
+        subject.coerce_value(String, lambda do |v|
+          return !!(v =~ /^(true|t|yes|y|1)$/i)
+        end)
+
+        true_values = %w(true t yes y 1)
+        false_values = %w(false f no n 0)
+
+        true_values.each do |v|
+          instance[:foo] = v
+          expect(instance[:foo]).to be_a(TrueClass)
+        end
+        false_values.each do |v|
+          instance[:foo] = v
+          expect(instance[:foo]).to be_a(FalseClass)
+        end
+      end
+    end
   end
 
   after(:each) do

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

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Hashie::Extensions::Dash::IndifferentAccess do
   class TrashWithIndifferentAccess < Hashie::Trash
     include Hashie::Extensions::Dash::IndifferentAccess
-    property :per_page, transform_with: lambda { |v| v.to_i }
+    property :per_page, transform_with: ->(v) { v.to_i }
     property :total, from: :total_pages
   end
 

data/spec/hashie/extensions/deep_find_spec.rb

@@ -0,0 +1,45 @@
+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/indifferent_access_spec.rb

@@ -52,6 +52,30 @@ describe Hashie::Extensions::IndifferentAccess 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
@@ -60,6 +84,30 @@ describe Hashie::Extensions::IndifferentAccess do
         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
     end
 
     describe '#delete' do