transproc 0.2.4 → 0.3.0

data/spec/unit/class_transformations_spec.rb

@@ -7,7 +7,7 @@ describe Transproc::ClassTransformations do
     end
 
     it 'returns a new object initialized with the given arguments' do
-      constructor_inject = t(:constructor_inject, klass)
+      constructor_inject = described_class.t(:constructor_inject, klass)
 
       input = ['Jane', 25]
       output = klass.new(*input)
@@ -33,7 +33,7 @@ describe Transproc::ClassTransformations do
     end
 
     it 'allocates a new object and sets instance variables from hash key/value pairs' do
-      set_ivars = t(:set_ivars, klass)
+      set_ivars = described_class.t(:set_ivars, klass)
 
       input = { name: 'Jane', age: 25 }
       output = klass.new(input)

data/spec/unit/coercions_spec.rb

@@ -3,69 +3,69 @@ require 'spec_helper'
 describe Transproc::Coercions do
   describe '.to_string' do
     it 'turns integer into a string' do
-      expect(t(:to_string)[1]).to eql('1')
+      expect(described_class.t(:to_string)[1]).to eql('1')
     end
   end
 
   describe '.to_symbol' do
     it 'turns string into a symbol' do
-      expect(t(:to_symbol)['test']).to eql(:test)
+      expect(described_class.t(:to_symbol)['test']).to eql(:test)
     end
   end
 
   describe '.to_integer' do
     it 'turns string into an integer' do
-      expect(t(:to_integer)['1']).to eql(1)
+      expect(described_class.t(:to_integer)['1']).to eql(1)
     end
   end
 
   describe '.to_float' do
     it 'turns string into a float' do
-      expect(t(:to_float)['1']).to eql(1.0)
+      expect(described_class.t(:to_float)['1']).to eql(1.0)
     end
 
     it 'turns integer into a float' do
-      expect(t(:to_float)[1]).to eql(1.0)
+      expect(described_class.t(:to_float)[1]).to eql(1.0)
     end
   end
 
   describe '.to_decimal' do
     it 'turns string into a decimal' do
-      expect(t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
+      expect(described_class.t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
     end
 
     it 'turns float into a decimal' do
-      expect(t(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
+      expect(described_class.t(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
     end
 
     it 'turns integer into a decimal' do
-      expect(t(:to_decimal)[1]).to eql(BigDecimal('1.0'))
+      expect(described_class.t(:to_decimal)[1]).to eql(BigDecimal('1.0'))
     end
   end
 
   describe '.to_date' do
     it 'turns string into a date' do
       date = Date.new(1983, 11, 18)
-      expect(t(:to_date)['18th, November 1983']).to eql(date)
+      expect(described_class.t(:to_date)['18th, November 1983']).to eql(date)
     end
   end
 
   describe '.to_time' do
     it 'turns string into a time object' do
       time = Time.new(2012, 1, 23, 11, 7, 7)
-      expect(t(:to_time)['2012-01-23 11:07:07']).to eql(time)
+      expect(described_class.t(:to_time)['2012-01-23 11:07:07']).to eql(time)
     end
   end
 
   describe '.to_datetime' do
     it 'turns string into a date' do
       datetime = DateTime.new(2012, 1, 23, 11, 7, 7)
-      expect(t(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
+      expect(described_class.t(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
     end
   end
 
   describe '.to_boolean' do
-    subject(:coercer) { t(:to_boolean) }
+    subject(:coercer) { described_class.t(:to_boolean) }
 
     Transproc::Coercions::TRUE_VALUES.each do |value|
       it "turns #{value.inspect} to true" do
@@ -81,7 +81,7 @@ describe Transproc::Coercions do
   end
 
   describe '.to_tuples' do
-    subject(:to_tuples) { t(:to_tuples) }
+    subject(:to_tuples) { described_class.t(:to_tuples) }
 
     context 'non-array' do
       let(:input) { :foo }

data/spec/unit/composer_spec.rb

@@ -1,14 +1,23 @@
 require 'spec_helper'
 
 describe Transproc::Composer do
+  before do
+    module Foo
+      extend Transproc::Registry
+      import Transproc::ArrayTransformations
+      import Transproc::HashTransformations
+      import Transproc::Coercions
+    end
+  end
+
   subject(:object) do
     Class.new do
       include Transproc::Composer
 
       def fn
         compose do |fns|
-          fns << t(:map_array, t(:symbolize_keys)) <<
-            t(:map_array, t(:map_value, :age, t(:to_integer)))
+          fns << Foo[:map_array, Foo[:symbolize_keys]] <<
+            Foo[:map_array, Foo[:map_value, :age, Foo[:to_integer]]]
         end
       end
     end.new
@@ -17,4 +26,6 @@ describe Transproc::Composer do
   it 'allows composing functions' do
     expect(object.fn[[{ 'age' => '12' }]]).to eql([{ age: 12 }])
   end
+
+  after { Object.send :remove_const, :Foo }
 end

data/spec/unit/conditional_spec.rb

@@ -2,7 +2,9 @@ require 'spec_helper'
 
 describe Transproc::Conditional do
   describe '.guard' do
-    let(:fn) { t(:guard, ->(value) { value.is_a?(::String) }, t(:to_integer)) }
+    let(:fn) { described_class.t(:guard, condition, operation) }
+    let(:condition) { ->(value) { value.is_a?(::String) } }
+    let(:operation) { Transproc::Coercions.t(:to_integer) }
 
     context 'when predicate returns truthy value' do
       it 'applies the transformation and returns the result' do

data/spec/unit/function_not_found_error_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+describe Transproc::FunctionNotFoundError do
+  it 'complains that the function not registered globally' do
+    expect { Transproc(:foo) }.to raise_error do |error|
+      expect(error).to be_kind_of described_class
+      expect(error.message["foo"]).not_to be_nil
+      expect(error.message["global"]).not_to be_nil
+    end
+  end
+
+  it 'complains that the function not registered locally' do
+    Foo = Module.new { extend Transproc::Registry }
+
+    expect { Foo[:foo] }.to raise_error do |error|
+      expect(error).to be_kind_of described_class
+      expect(error.message["function Foo[:foo]"]).not_to be_nil
+    end
+  end
+end

data/spec/unit/function_spec.rb

@@ -1,10 +1,28 @@
 require 'spec_helper'
 
-describe 'Transproc::Function' do
+describe Transproc::Function do
+  let(:hashes) { Transproc::HashTransformations }
+
+  describe '#name' do
+    let(:block) { proc { |v| v } }
+
+    it 'returns the name of the module function' do
+      expect(hashes[:symbolize_keys].name).to eql :symbolize_keys
+    end
+
+    it 'returns the explicitly assigned name' do
+      expect(described_class.new(block, name: :identity).name).to eql :identity
+    end
+
+    it 'returns the unnamed closure' do
+      expect(described_class.new(block).name).to eql block
+    end
+  end
+
   describe '#>>' do
     it 'composes named functions' do
-      f1 = t(:symbolize_keys)
-      f2 = t(:rename_keys, user_name: :name)
+      f1 = hashes[:symbolize_keys]
+      f2 = hashes[:rename_keys, user_name: :name]
 
       f3 = f1 >> f2
 
@@ -19,7 +37,7 @@ describe 'Transproc::Function' do
 
       expect(f3['user_name' => 'Jane']).to eql(name: 'Jane')
 
-      f4 = f3 >> t(:nest, :details, [:name])
+      f4 = f3 >> hashes[:nest, :details, [:name]]
 
       expect(f4.to_ast).to eql(
         [
@@ -54,7 +72,7 @@ describe 'Transproc::Function' do
     end
 
     it 'plays well with registered compositions' do
-      Transproc.register(:user_names, t(:symbolize_keys) + t(:rename_keys, user_name: :name))
+      Transproc.register(:user_names, hashes[:symbolize_keys] + hashes[:rename_keys, user_name: :name])
       f = t(:user_names)
 
       expect(f['user_name' => 'Jane']).to eql(name: 'Jane')
@@ -70,10 +88,33 @@ describe 'Transproc::Function' do
 
     it 'plays well with registered functions' do
       Transproc.register(:to_s, t(:to_string))
-      f = t(:to_s)
+      fn = t(:to_s)
+
+      expect(fn[:ok]).to eql('ok')
+      expect(fn.to_ast).to eql([:to_string, []])
+    end
+  end
+
+  describe '#==' do
+    let(:fns) do
+      Module.new do
+        extend Transproc::Registry
+        import :wrap, from: Transproc::ArrayTransformations
+      end
+    end
+
+    it 'returns true when the other is equal' do
+      left = fns[:wrap, :user, [:name, :email]]
+      right = fns[:wrap, :user, [:name, :email]]
+
+      expect(left == right).to be(true)
+    end
+
+    it 'returns false when the other is not a fn' do
+      left = fns[:wrap, :user, [:name, :email]]
+      right = 'boo!'
 
-      expect(f[:ok]).to eql('ok')
-      expect(f.to_ast).to eql([:to_string, []])
+      expect(left == right).to be(false)
     end
   end
 end

data/spec/unit/hash_transformations_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
+require 'transproc/rspec'
 
 describe Transproc::HashTransformations do
   describe '.map_keys' do
     it 'returns a new hash with given proc applied to keys' do
-      map_keys = t(:map_keys, ->(key) { key.strip })
+      map_keys = described_class.t(:map_keys, ->(key) { key.strip })
 
       input = { ' foo ' => 'bar' }
       output = { 'foo' => 'bar' }
@@ -15,7 +16,7 @@ describe Transproc::HashTransformations do
 
   describe '.map_keys!' do
     it 'returns updated hash with given proc applied to keys' do
-      map_keys = t(:map_keys!, ->(key) { key.strip })
+      map_keys = described_class.t(:map_keys!, ->(key) { key.strip })
 
       input = { ' foo ' => 'bar' }
       output = { 'foo' => 'bar' }
@@ -27,7 +28,7 @@ describe Transproc::HashTransformations do
 
   describe '.symbolize_keys' do
     it 'returns a new hash with symbolized keys' do
-      symbolize_keys = t(:symbolize_keys)
+      symbolize_keys = described_class.t(:symbolize_keys)
 
       input = { 'foo' => 'bar' }
       output = { foo: 'bar' }
@@ -37,9 +38,21 @@ describe Transproc::HashTransformations do
     end
   end
 
+  describe '.deep_symbolize_keys' do
+    it 'returns a new hash with symbolized keys' do
+      symbolize_keys = described_class.t(:deep_symbolize_keys)
+
+      input = { 'foo' => 'bar', 'baz' => [{ 'one' => 1 }, 'two'] }
+      output = { foo: 'bar', baz: [{ one: 1 }, 'two'] }
+
+      expect(symbolize_keys[input]).to eql(output)
+      expect(input).to eql({ 'foo' => 'bar', 'baz' => [{ 'one' => 1 }, 'two'] })
+    end
+  end
+
   describe '.symbolize_keys!' do
     it 'returns updated hash with symbolized keys' do
-      symbolize_keys = t(:symbolize_keys!)
+      symbolize_keys = described_class.t(:symbolize_keys!)
 
       input = { 'foo' => 'bar' }
       output = { foo: 'bar' }
@@ -52,7 +65,7 @@ describe Transproc::HashTransformations do
 
   describe '.stringify_keys' do
     it 'returns a new hash with stringified keys' do
-      stringify_keys = t(:stringify_keys)
+      stringify_keys = described_class.t(:stringify_keys)
 
       input = { foo: 'bar' }
       output = { 'foo' => 'bar' }
@@ -64,7 +77,7 @@ describe Transproc::HashTransformations do
 
   describe '.stringify_keys!' do
     it 'returns a new hash with stringified keys' do
-      stringify_keys = t(:stringify_keys!)
+      stringify_keys = described_class.t(:stringify_keys!)
 
       input = { foo: 'bar' }
       output = { 'foo' => 'bar' }
@@ -76,7 +89,7 @@ describe Transproc::HashTransformations do
 
   describe '.map_values' do
     it 'returns a new hash with given proc applied to values' do
-      map_values = t(:map_values, ->(value) { value.strip })
+      map_values = described_class.t(:map_values, ->(value) { value.strip })
 
       input = { 'foo' => ' bar ' }
       output = { 'foo' => 'bar' }
@@ -88,7 +101,7 @@ describe Transproc::HashTransformations do
 
   describe '.map_values!' do
     it 'returns updated hash with given proc applied to values' do
-      map_values = t(:map_values!, ->(value) { value.strip })
+      map_values = described_class.t(:map_values!, ->(value) { value.strip })
 
       input = { 'foo' => ' bar ' }
       output = { 'foo' => 'bar' }
@@ -100,7 +113,7 @@ describe Transproc::HashTransformations do
 
   describe '.rename_keys' do
     it 'returns a new hash with applied functions' do
-      map = t(:rename_keys, 'foo' => :foo)
+      map = described_class.t(:rename_keys, 'foo' => :foo)
 
       input = { 'foo' => 'bar', :bar => 'baz' }
       output = { foo: 'bar', bar: 'baz' }
@@ -112,7 +125,7 @@ describe Transproc::HashTransformations do
 
   describe '.rename_keys!' do
     it 'returns updated hash with applied functions' do
-      map = t(:rename_keys!, 'foo' => :foo)
+      map = described_class.t(:rename_keys!, 'foo' => :foo)
 
       input = { 'foo' => 'bar', :bar => 'baz' }
       output = { foo: 'bar', bar: 'baz' }
@@ -125,7 +138,8 @@ describe Transproc::HashTransformations do
 
   describe '.map_value' do
     it 'applies function to value under specified key' do
-      transformation = t(:map_value, :user, t(:symbolize_keys))
+      transformation =
+        described_class.t(:map_value, :user, described_class.t(:symbolize_keys))
 
       input = { user: { 'name' => 'Jane' } }
       output = { user: { name: 'Jane' } }
@@ -137,7 +151,9 @@ describe Transproc::HashTransformations do
 
   describe '.map_value!' do
     it 'applies function to value under specified key' do
-      transformation = t(:map_value!, :user, t(:symbolize_keys))
+      transformation =
+        described_class
+        .t(:map_value!, :user, described_class.t(:symbolize_keys))
 
       input = { user: { 'name' => 'Jane' } }
       output = { user: { name: 'Jane' } }
@@ -150,7 +166,7 @@ describe Transproc::HashTransformations do
 
   describe '.nest' do
     it 'returns new hash with keys nested under a new key' do
-      nest = t(:nest, :baz, ['foo'])
+      nest = described_class.t(:nest, :baz, ['foo'])
 
       input = { 'foo' => 'bar' }
       output = { baz: { 'foo' => 'bar' } }
@@ -162,7 +178,7 @@ describe Transproc::HashTransformations do
 
   describe '.nest!' do
     it 'returns new hash with keys nested under a new key' do
-      nest = t(:nest!, :baz, ['one', 'two', 'not-here'])
+      nest = described_class.t(:nest!, :baz, ['one', 'two', 'not-here'])
 
       input = { 'foo' => 'bar', 'one' => nil, 'two' => false }
       output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
@@ -173,7 +189,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'returns new hash with keys nested under the existing key' do
-      nest = t(:nest!, :baz, ['two'])
+      nest = described_class.t(:nest!, :baz, ['two'])
 
       input  = { 'foo' => 'bar', baz: { 'one' => nil }, 'two' => false }
       output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
@@ -184,7 +200,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'rewrites the existing key if its value is not a hash' do
-      nest = t(:nest!, :baz, ['two'])
+      nest = described_class.t(:nest!, :baz, ['two'])
 
       input  = { 'foo' => 'bar', baz: 'one', 'two' => false }
       output = { 'foo' => 'bar', baz: { 'two' => false } }
@@ -195,7 +211,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'returns new hash with an empty hash under a new key when nest-keys are missing' do
-      nest = t(:nest!, :baz, ['foo'])
+      nest = described_class.t(:nest!, :baz, ['foo'])
 
       input = { 'bar' => 'foo' }
       output = { 'bar' => 'foo', baz: {} }
@@ -208,7 +224,7 @@ describe Transproc::HashTransformations do
 
   describe '.unwrap!' do
     it 'returns updated hash with nested keys lifted to the root' do
-      unwrap = t(:unwrap!, 'wrapped', %w(one))
+      unwrap = described_class.t(:unwrap!, 'wrapped', %w(one))
 
       input = { 'foo' => 'bar', 'wrapped' => { 'one' => nil, 'two' => false } }
       output = { 'foo' => 'bar', 'one' => nil, 'wrapped' => { 'two' => false } }
@@ -219,7 +235,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'lifts all keys if none are passed' do
-      unwrap = t(:unwrap!, 'wrapped')
+      unwrap = described_class.t(:unwrap!, 'wrapped')
 
       input = { 'wrapped' => { 'one' => nil, 'two' => false } }
       output = { 'one' => nil, 'two' => false }
@@ -230,7 +246,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'ignores unknown keys' do
-      unwrap = t(:unwrap!, 'wrapped', %w(one two three))
+      unwrap = described_class.t(:unwrap!, 'wrapped', %w(one two three))
 
       input = { 'wrapped' => { 'one' => nil, 'two' => false } }
       output = { 'one' => nil, 'two' => false }
@@ -243,7 +259,7 @@ describe Transproc::HashTransformations do
 
   describe '.unwrap' do
     it 'returns new hash with nested keys lifted to the root' do
-      unwrap = t(:unwrap, 'wrapped')
+      unwrap = described_class.t(:unwrap, 'wrapped')
 
       input = {
         'foo' => 'bar',
@@ -260,8 +276,8 @@ describe Transproc::HashTransformations do
 
   describe 'nested transform' do
     it 'applies functions to nested hashes' do
-      symbolize_keys = t(:symbolize_keys)
-      map_user_key = t(:map_value, :user, symbolize_keys)
+      symbolize_keys = described_class.t(:symbolize_keys)
+      map_user_key = described_class.t(:map_value, :user, symbolize_keys)
 
       transformation = symbolize_keys >> map_user_key
 
@@ -274,8 +290,8 @@ describe Transproc::HashTransformations do
 
   describe 'combining transformations' do
     it 'applies functions to the hash' do
-      symbolize_keys = t(:symbolize_keys)
-      map = t(:rename_keys, user_name: :name, user_email: :email)
+      symbolize_keys = described_class.t(:symbolize_keys)
+      map = described_class.t(:rename_keys, user_name: :name, user_email: :email)
 
       transformation = symbolize_keys >> map
 
@@ -290,7 +306,7 @@ describe Transproc::HashTransformations do
 
   describe '.reject_keys!' do
     it 'returns an updated hash with rejected keys' do
-      reject_keys = t(:reject_keys, [:name, :age])
+      reject_keys = described_class.t(:reject_keys, [:name, :age])
 
       input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
       output = { email: 'jane@doe.org' }
@@ -301,7 +317,7 @@ describe Transproc::HashTransformations do
 
   describe '.reject_keys' do
     it 'returns a new hash with rejected keys' do
-      reject_keys = t(:reject_keys, [:name, :age])
+      reject_keys = described_class.t(:reject_keys, [:name, :age])
 
       input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
       output = { email: 'jane@doe.org' }
@@ -313,7 +329,7 @@ describe Transproc::HashTransformations do
 
   describe '.accept_keys!' do
     it 'returns an updated hash with accepted keys' do
-      accept_keys = t(:accept_keys, [:age])
+      accept_keys = described_class.t(:accept_keys, [:age])
 
       input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
       output = { age: 21 }
@@ -324,7 +340,7 @@ describe Transproc::HashTransformations do
 
   describe '.reject_keys' do
     it 'returns a new hash with rejected keys' do
-      accept_keys = t(:accept_keys, [:age])
+      accept_keys = described_class.t(:accept_keys, [:age])
 
       input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
       output = { age: 21 }
@@ -342,22 +358,14 @@ describe Transproc::HashTransformations do
       }
     end
 
-    it 'returns an updated hash with folded key' do
-      fold = t(:fold, :tasks, :title)
-
-      output = { name: 'Jane', tasks: ['be nice', 'sleep well'] }
-
-      expect { fold[input] }.not_to change { input }
-      expect(fold[input]).to eq output
+    it_behaves_like :transforming_immutable_data do
+      let(:arguments) { [:fold, :tasks, :title] }
+      let(:output)    { { name: 'Jane', tasks: ['be nice', 'sleep well'] } }
     end
 
-    it 'does not compact results' do
-      fold = t(:fold, :tasks, :priority)
-
-      output = { name: 'Jane', tasks: [1, nil] }
-
-      expect { fold[input] }.not_to change { input }
-      expect(fold[input]).to eql output
+    it_behaves_like :transforming_immutable_data do
+      let(:arguments) { [:fold, :tasks, :priority] }
+      let(:output)    { { name: 'Jane', tasks: [1, nil] } }
     end
   end
 
@@ -369,22 +377,14 @@ describe Transproc::HashTransformations do
       }
     end
 
-    it 'returns an updated hash with folded key' do
-      fold = t(:fold!, :tasks, :title)
-
-      output = { name: 'Jane', tasks: ['be nice', 'sleep well'] }
-
-      expect(fold[input]).to eql output
-      expect(input).to eql output
+    it_behaves_like :mutating_input_data do
+      let(:arguments) { [:fold!, :tasks, :title] }
+      let(:output)    { { name: 'Jane', tasks: ['be nice', 'sleep well'] } }
     end
 
-    it 'does not compact results' do
-      fold = t(:fold!, :tasks, :priority)
-
-      output = { name: 'Jane', tasks: [1, nil] }
-
-      expect(fold[input]).to eql output
-      expect(input).to eql output
+    it_behaves_like :mutating_input_data do
+      let(:arguments) { [:fold!, :tasks, :priority] }
+      let(:output)    { { name: 'Jane', tasks: [1, nil] } }
     end
   end
 
@@ -403,7 +403,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'splits a tuple into array partially by given keys' do
-      split = t(:split, :tasks, [:priority])
+      split = described_class.t(:split, :tasks, [:priority])
 
       output = [
         {
@@ -424,7 +424,7 @@ describe Transproc::HashTransformations do
     end
 
     it 'splits a tuple into array fully by all subkeys' do
-      split = t(:split, :tasks, [:priority, :title])
+      split = described_class.t(:split, :tasks, [:priority, :title])
 
       output = [
         { name: 'Joe', title: 'sleep well', priority: 1   },
@@ -451,24 +451,62 @@ describe Transproc::HashTransformations do
         }
       ]
 
-      split = t(:split, :tasks, [])
+      split = described_class.t(:split, :tasks, [])
       expect(split[input]).to eql output
 
-      split = t(:split, :tasks, [:absent])
+      split = described_class.t(:split, :tasks, [:absent])
       expect(split[input]).to eql output
     end
 
     it 'returns an array of initial tuple when attribute is absent' do
-      split = t(:split, :absent, [:priority, :title])
+      split = described_class.t(:split, :absent, [:priority, :title])
       expect(split[input]).to eql [input]
     end
 
     it 'ignores empty array' do
       input = { name: 'Joe', tasks: [] }
 
-      split = t(:split, :tasks, [:title])
+      split = described_class.t(:split, :tasks, [:title])
 
       expect(split[input]).to eql [{ name: 'Joe' }]
     end
   end
+
+  describe ':eval_values' do
+    it 'recursively evaluates values' do
+      evaluate = described_class.t(:eval_values, 1)
+
+      input = {
+        one: 1, two: -> i { i+1 },
+        three: -> i { i+2 }, four: 4,
+        more: [{ one: -> i { i }, two: 2 }]
+      }
+
+      output = {
+        one: 1, two: 2,
+        three: 3, four: 4,
+        more: [{ one: 1, two: 2 }]
+      }
+
+      expect(evaluate[input]).to eql(output)
+    end
+
+    it 'recursively evaluates values matching key names' do
+      evaluate = described_class.t(:eval_values, 1, [:one, :two])
+
+      input = {
+        one: 1, two: -> i { i+1 },
+        three: -> i { i+2 }, four: 4,
+        array: [{ one: -> i { i }, two: 2 }],
+        hash: { one: -> i { i } }
+      }
+
+      result = evaluate[input]
+
+      expect(result[:three]).to be_a(Proc)
+      expect(result).to include(two: 2)
+      expect(result[:array]).to eql([{ one: 1, two: 2 }])
+      expect(result[:hash]).to eql(one: 1)
+    end
+  end
 end