dry-transformer 0.1.0

data/spec/unit/class_transformations_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'dry/equalizer'
+
+RSpec.describe Dry::Transformer::ClassTransformations do
+  describe '.constructor_inject' do
+    let(:klass) do
+      Struct.new(:name, :age) { include Dry::Equalizer.new(:name, :age) }
+    end
+
+    it 'returns a new object initialized with the given arguments' do
+      constructor_inject = described_class.t(:constructor_inject, klass)
+
+      input = ['Jane', 25]
+      output = klass.new(*input)
+      result = constructor_inject[*input]
+
+      expect(result).to eql(output)
+      expect(result).to be_instance_of(klass)
+    end
+  end
+
+  describe '.set_ivars' do
+    let(:klass) do
+      Class.new do
+        include Dry::Equalizer.new(:name, :age)
+
+        attr_reader :name, :age, :test
+
+        def initialize(name:, age:)
+          @name = name
+          @age = age
+          @test = true
+        end
+      end
+    end
+
+    it 'allocates a new object and sets instance variables from hash key/value pairs' do
+      set_ivars = described_class.t(:set_ivars, klass)
+
+      input = { name: 'Jane', age: 25 }
+      output = klass.new(input)
+      result = set_ivars[input]
+
+      expect(result).to eql(output)
+      expect(result.test).to be(nil)
+      expect(result).to be_instance_of(klass)
+    end
+  end
+end

data/spec/unit/coercions_spec.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::Coercions do
+  describe '.identity' do
+    let(:fn) { described_class.t(:identity) }
+
+    it 'returns the original value' do
+      expect(fn[:foo]).to eql :foo
+    end
+
+    it 'returns nil by default' do
+      expect(fn[]).to eql nil
+    end
+  end
+
+  describe '.to_string' do
+    it 'turns integer into a string' do
+      expect(described_class.t(:to_string)[1]).to eql('1')
+    end
+  end
+
+  describe '.to_symbol' do
+    it 'turns string into a symbol' do
+      expect(described_class.t(:to_symbol)['test']).to eql(:test)
+    end
+
+    it 'turns non-string into a symbol' do
+      expect(described_class.t(:to_symbol)[1]).to eql(:'1')
+    end
+  end
+
+  describe '.to_integer' do
+    it 'turns string into an integer' do
+      expect(described_class.t(:to_integer)['1']).to eql(1)
+    end
+  end
+
+  describe '.to_float' do
+    it 'turns string into a float' do
+      expect(described_class.t(:to_float)['1']).to eql(1.0)
+    end
+
+    it 'turns integer into a float' do
+      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(described_class.t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
+    end
+
+    it 'turns float into a decimal' do
+      expect(described_class.t(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
+    end
+
+    it 'turns integer into a decimal' do
+      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(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(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(described_class.t(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
+    end
+  end
+
+  describe '.to_boolean' do
+    subject(:coercer) { described_class.t(:to_boolean) }
+
+    Dry::Transformer::Coercions::TRUE_VALUES.each do |value|
+      it "turns #{value.inspect} to true" do
+        expect(coercer[value]).to be(true)
+      end
+    end
+
+    Dry::Transformer::Coercions::FALSE_VALUES.each do |value|
+      it "turns #{value.inspect} to false" do
+        expect(coercer[value]).to be(false)
+      end
+    end
+  end
+
+  describe '.to_tuples' do
+    subject(:to_tuples) { described_class.t(:to_tuples) }
+
+    context 'non-array' do
+      let(:input) { :foo }
+
+      it 'returns an array with one blank tuple' do
+        output = [{}]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+
+    context 'empty array' do
+      let(:input) { [] }
+
+      it 'returns an array with one blank tuple' do
+        output = [{}]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+
+    context 'array of tuples' do
+      let(:input) { [:foo, { bar: :BAZ }, :qux] }
+
+      it 'returns an array with tuples only' do
+        output = [{ bar: :BAZ }]
+
+        expect(to_tuples[input]).to eql(output)
+      end
+    end
+  end
+end

data/spec/unit/conditional_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::Conditional do
+  describe '.not' do
+    let(:fn) { described_class.t(:not, -> value { value.is_a? String }) }
+    subject  { fn[input] }
+
+    context 'when predicate returns truthy value' do
+      let(:input)  { 'foo' }
+      let(:output) { false }
+
+      it 'applies the first transformation' do
+        expect(subject).to eql output
+      end
+    end
+
+    context 'when predicate returns falsey value' do
+      let(:input)  { :foo }
+      let(:output) { true }
+
+      it 'applies the first transformation' do
+        expect(subject).to eql output
+      end
+    end
+  end
+
+  describe '.guard' do
+    let(:fn) { described_class.t(:guard, condition, operation) }
+    let(:condition) { ->(value) { value.is_a?(::String) } }
+    let(:operation) { Dry::Transformer::Coercions.t(:to_integer) }
+
+    context 'when predicate returns truthy value' do
+      it 'applies the transformation and returns the result' do
+        input = '2'
+
+        expect(fn[input]).to eql(2)
+      end
+    end
+
+    context 'when predicate returns falsey value' do
+      it 'returns the original value' do
+        input = { 'foo' => 'bar' }
+
+        expect(fn[input]).to eql('foo' => 'bar')
+      end
+    end
+  end
+end

data/spec/unit/function_not_found_error_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::FunctionNotFoundError do
+  it 'complains that the function not registered' do
+    Foo = Module.new { extend Dry::Transformer::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

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::Function do
+  let(:container) do
+    Module.new do
+      extend Dry::Transformer::Registry
+
+      import Dry::Transformer::HashTransformations
+    end
+  end
+
+  describe '#name' do
+    let(:block) { proc { |v| v } }
+
+    it 'returns the name of the module function' do
+      expect(container[: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 = container[:symbolize_keys]
+      f2 = container[:rename_keys, user_name: :name]
+
+      f3 = f1 >> f2
+
+      expect(f3.to_ast).to eql(
+        [
+          :symbolize_keys, [],
+          [
+            :rename_keys, [user_name: :name]
+          ]
+        ]
+      )
+
+      expect(f3['user_name' => 'Jane']).to eql(name: 'Jane')
+
+      f4 = f3 >> container[:nest, :details, [:name]]
+
+      expect(f4.to_ast).to eql(
+        [
+          :symbolize_keys, [],
+          [
+            :rename_keys, [user_name: :name]
+          ],
+          [
+            :nest, [:details, [:name]]
+          ]
+        ]
+      )
+
+      expect(f4['user_name' => 'Jane']).to eql(details: { name: 'Jane' })
+    end
+
+    it 'composes anonymous functions' do
+      f1 = container[->(v, m) { v * m }, 2]
+      f2 = container[:to_s.to_proc]
+
+      f3 = f1 >> f2
+
+      expect(f3.to_ast).to eql(
+        [
+          f1.fn, [2],
+          [
+            f2.fn, []
+          ]
+        ]
+      )
+    end
+
+    it 'plays well with registered compositions' do
+      container.register(:user_names, container[:symbolize_keys] + container[:rename_keys, user_name: :name])
+      f = container[:user_names]
+
+      expect(f['user_name' => 'Jane']).to eql(name: 'Jane')
+      expect(f.to_ast).to eql(
+        [
+          :symbolize_keys, [],
+          [
+            :rename_keys, [user_name: :name]
+          ]
+        ]
+      )
+    end
+
+    it 'plays well with registered functions' do
+      container.register(:to_string, Dry::Transformer::Coercions.t(:to_string))
+      fn = container.t(:to_string)
+
+      expect(fn[:ok]).to eql('ok')
+      expect(fn.to_ast).to eql([:to_string, []])
+    end
+
+    it 'plays well with functions as arguments' do
+      container.register(:map_array, Dry::Transformer::ArrayTransformations.t(:map_array))
+      container.register(:to_symbol, Dry::Transformer::Coercions.t(:to_symbol))
+      fn = container.t(:map_array, container.t(:to_symbol))
+
+      expect(fn.call(%w(a b c))).to eql([:a, :b, :c])
+      expect(fn.to_ast).to eql(
+        [
+          :map_array, [
+            [:to_symbol, []]
+          ]
+        ]
+      )
+    end
+  end
+
+  describe '#==' do
+    let(:fns) do
+      Module.new do
+        extend Dry::Transformer::Registry
+        import :wrap, from: Dry::Transformer::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(left == right).to be(false)
+    end
+  end
+
+  describe '#to_proc' do
+    shared_examples :providing_a_proc do
+      let(:fn) { described_class.new(source) }
+      subject  { fn.to_proc }
+
+      it 'returns a proc' do
+        expect(subject).to be_instance_of Proc
+      end
+
+      it 'works fine' do
+        expect(subject.call :foo).to eql('foo')
+      end
+    end
+
+    context 'from a method' do
+      let(:source) do
+        mod = Module.new do
+          def self.get(x)
+            x.to_s
+          end
+        end
+        mod.method(:get)
+      end
+      it_behaves_like :providing_a_proc
+    end
+
+    context 'from a proc' do
+      let(:source) { -> value { value.to_s } }
+      it_behaves_like :providing_a_proc
+    end
+
+    context 'from a transproc' do
+      let(:source) { Dry::Transformer::Function.new -> value { value.to_s } }
+      it_behaves_like :providing_a_proc
+
+      it 'can be applied to collection' do
+        expect([:foo, :bar].map(&source)).to eql(%w(foo bar))
+      end
+    end
+
+    context 'with curried args' do
+      let(:source) { -> i, j { [i, j].join(' ') } }
+
+      it 'works fine' do
+        fn = described_class.new(source, args: ['world'])
+
+        result = fn.to_proc.call('hello')
+
+        expect(result).to eql('hello world')
+      end
+    end
+  end
+end

data/spec/unit/hash_transformations_spec.rb

@@ -0,0 +1,490 @@
+# frozen_string_literal: true
+
+RSpec.describe Dry::Transformer::HashTransformations do
+  describe '.map_keys' do
+    it 'returns a new hash with given proc applied to keys' do
+      map_keys = described_class.t(:map_keys, ->(key) { key.strip })
+
+      input = { ' foo ' => 'bar' }.freeze
+      output = { 'foo' => 'bar' }
+
+      expect(map_keys[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:map_keys!) }
+
+  describe '.symbolize_keys' do
+    it 'returns a new hash with symbolized keys' do
+      symbolize_keys = described_class.t(:symbolize_keys)
+
+      input = { 1 => 'bar' }.freeze
+      output = { '1'.to_sym => 'bar' }
+
+      expect(symbolize_keys[input]).to eql(output)
+    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
+
+  it { expect(described_class).not_to be_contain(:symbolize_keys!) }
+
+  describe '.stringify_keys' do
+    it 'returns a new hash with stringified keys' do
+      stringify_keys = described_class.t(:stringify_keys)
+
+      input = { foo: 'bar' }.freeze
+      output = { 'foo' => 'bar' }
+
+      expect(stringify_keys[input]).to eql(output)
+    end
+  end
+
+  describe '.deep_stringify_keys' do
+    it 'returns a new hash with symbolized keys' do
+      stringify_keys = described_class.t(:deep_stringify_keys)
+
+      input = { foo: 'bar', baz: [{ one: 1 }, 'two'] }
+      output = { 'foo' => 'bar', 'baz' => [{ 'one' => 1 }, 'two'] }
+
+      expect(stringify_keys[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:stringify_keys!) }
+
+  describe '.map_values' do
+    it 'returns a new hash with given proc applied to values' do
+      map_values = described_class.t(:map_values, ->(value) { value.strip })
+
+      input = { 'foo' => ' bar ' }.freeze
+      output = { 'foo' => 'bar' }
+
+      expect(map_values[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:map_values!) }
+
+  describe '.rename_keys' do
+    it 'returns a new hash with applied functions' do
+      map = described_class.t(:rename_keys, 'foo' => :foo)
+
+      input = { 'foo' => 'bar', :bar => 'baz' }.freeze
+      output = { foo: 'bar', bar: 'baz' }
+
+      expect(map[input]).to eql(output)
+    end
+
+    it 'only renames keys and never creates new ones' do
+      map = described_class.t(:rename_keys, 'foo' => :foo, 'bar' => :bar)
+
+      input = { 'bar' => 'baz' }.freeze
+      output = { bar: 'baz' }
+
+      expect(map[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:rename_keys!) }
+
+  describe '.copy_keys' do
+    context 'with single destination key' do
+      it 'returns a new hash with applied functions' do
+        map = described_class.t(:copy_keys, 'foo' => :foo)
+
+        input = { 'foo' => 'bar', :bar => 'baz' }.freeze
+        output = { 'foo' => 'bar', foo: 'bar', bar: 'baz' }
+
+        expect(map[input]).to eql(output)
+      end
+    end
+
+    context 'with multiple destination keys' do
+      it 'returns a new hash with applied functions' do
+        map = described_class.t(:copy_keys, 'foo' => [:foo, :baz])
+
+        input = { 'foo' => 'bar', :bar => 'baz' }.freeze
+        output = { 'foo' => 'bar', foo: 'bar', baz: 'bar', bar: 'baz' }
+
+        expect(map[input]).to eql(output)
+      end
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:copy_keys!) }
+
+  describe '.map_value' do
+    it 'applies function to value under specified key' do
+      transformation =
+        described_class.t(:map_value, :user, described_class.t(:symbolize_keys))
+
+      input = { user: { 'name' => 'Jane' }.freeze }.freeze
+      output = { user: { name: 'Jane' } }
+
+      expect(transformation[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:map_value!) }
+
+  describe '.nest' do
+    it 'returns new hash with keys nested under a new key' do
+      nest = described_class.t(:nest, :baz, ['foo'])
+
+      input = { 'foo' => 'bar' }.freeze
+      output = { baz: { 'foo' => 'bar' } }
+
+      expect(nest[input]).to eql(output)
+    end
+
+    it 'returns new hash with keys nested under the existing key' do
+      nest = described_class.t(:nest, :baz, ['two'])
+
+      input = {
+        'foo' => 'bar',
+        baz: { 'one' => nil }.freeze,
+        'two' => false
+      }.freeze
+
+      output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
+
+      expect(nest[input]).to eql(output)
+    end
+
+    it 'rewrites the existing key if its value is not a hash' do
+      nest = described_class.t(:nest, :baz, ['two'])
+
+      input  = { 'foo' => 'bar', baz: 'one', 'two' => false }.freeze
+      output = { 'foo' => 'bar', baz: { 'two' => false } }
+
+      expect(nest[input]).to eql(output)
+    end
+
+    it 'returns new hash with an empty hash under a new key when nest-keys are missing' do
+      nest = described_class.t(:nest, :baz, ['foo'])
+
+      input = { 'bar' => 'foo' }.freeze
+      output = { 'bar' => 'foo', baz: {} }
+
+      expect(nest[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:nest!) }
+
+  describe '.unwrap' do
+    it 'returns new hash with nested keys lifted to the root' do
+      unwrap = described_class.t(:unwrap, 'wrapped', %w(one))
+
+      input = {
+        'foo' => 'bar',
+        'wrapped' => { 'one' => nil, 'two' => false }.freeze
+      }.freeze
+
+      output = { 'foo' => 'bar', 'one' => nil, 'wrapped' => { 'two' => false } }
+
+      expect(unwrap[input]).to eql(output)
+    end
+
+    it 'lifts all keys if none are passed' do
+      unwrap = described_class.t(:unwrap, 'wrapped')
+
+      input = { 'wrapped' => { 'one' => nil, 'two' => false }.freeze }.freeze
+      output = { 'one' => nil, 'two' => false }
+
+      expect(unwrap[input]).to eql(output)
+    end
+
+    it 'ignores unknown keys' do
+      unwrap = described_class.t(:unwrap, 'wrapped', %w(one two three))
+
+      input = { 'wrapped' => { 'one' => nil, 'two' => false }.freeze }.freeze
+      output = { 'one' => nil, 'two' => false }
+
+      expect(unwrap[input]).to eql(output)
+    end
+
+    it 'prefixes unwrapped keys and retains root string type if prefix option is truthy' do
+      unwrap = described_class.t(:unwrap, 'wrapped', prefix: true)
+
+      input = { 'wrapped' => { one: nil, two: false }.freeze }.freeze
+      output = { 'wrapped_one' => nil, 'wrapped_two' => false }
+
+      expect(unwrap[input]).to eql(output)
+    end
+
+    it 'prefixes unwrapped keys and retains root type if prefix option is truthy' do
+      unwrap = described_class.t(:unwrap, :wrapped, prefix: true)
+
+      input = { wrapped: { 'one' => nil, 'two' => false }.freeze }.freeze
+      output = { wrapped_one: nil, wrapped_two: false }
+
+      expect(unwrap[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:unwrap!) }
+
+  describe 'nested transform' do
+    it 'applies functions to nested hashes' do
+      symbolize_keys = described_class.t(:symbolize_keys)
+      map_user_key = described_class.t(:map_value, :user, symbolize_keys)
+
+      transformation = symbolize_keys >> map_user_key
+
+      input = { 'user' => { 'name' => 'Jane' } }
+      output = { user: { name: 'Jane' } }
+
+      expect(transformation[input]).to eql(output)
+    end
+  end
+
+  describe 'combining transformations' do
+    it 'applies functions to the hash' do
+      symbolize_keys = described_class.t(:symbolize_keys)
+      map = described_class.t :rename_keys, user_name: :name, user_email: :email
+
+      transformation = symbolize_keys >> map
+
+      input = { 'user_name' => 'Jade', 'user_email' => 'jade@doe.org' }
+      output = { name: 'Jade', email: 'jade@doe.org' }
+
+      result = transformation[input]
+
+      expect(result).to eql(output)
+    end
+  end
+
+  describe '.reject_keys' do
+    it 'returns a new hash with rejected keys' do
+      reject_keys = described_class.t(:reject_keys, [:name, :age])
+
+      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }.freeze
+      output = { email: 'jane@doe.org' }
+
+      expect(reject_keys[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:reject_keys!) }
+
+  describe '.accept_keys' do
+    it 'returns a new hash with rejected keys' do
+      accept_keys = described_class.t(:accept_keys, [:age])
+
+      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }.freeze
+      output = { age: 21 }
+
+      expect(accept_keys[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:accept_keys!) }
+
+  describe '.fold' do
+    let(:input) do
+      {
+        name: 'Jane',
+        tasks: [
+          { title: 'be nice', priority: 1 }.freeze,
+          { title: 'sleep well' }.freeze
+        ].freeze
+      }.freeze
+    end
+
+    it 'returns a new hash with folded values' do
+      fold = described_class.t(:fold, :tasks, :title)
+
+      output = { name: 'Jane', tasks: ['be nice', 'sleep well'] }
+
+      expect(fold[input]).to eql(output)
+    end
+
+    it 'uses nil if there was not such attribute' do
+      fold = described_class.t(:fold, :tasks, :priority)
+
+      output = { name: 'Jane', tasks: [1, nil] }
+
+      expect(fold[input]).to eql(output)
+    end
+  end
+
+  it { expect(described_class).not_to be_contain(:fold!) }
+
+  describe '.split' do
+    let(:input) do
+      {
+        name: 'Joe',
+        tasks: [
+          { title: 'sleep well', priority: 1   },
+          { title: 'be nice',    priority: 2   },
+          {                      priority: 2   },
+          { title: 'be cool'                   },
+          {}
+        ]
+      }
+    end
+
+    it 'splits a tuple into array partially by given keys' do
+      split = described_class.t(:split, :tasks, [:priority])
+
+      output = [
+        {
+          name: 'Joe', priority: 1,
+          tasks: [{ title: 'sleep well' }]
+        },
+        {
+          name: 'Joe', priority: 2,
+          tasks: [{ title: 'be nice' }, { title: nil }]
+        },
+        {
+          name: 'Joe', priority: nil,
+          tasks: [{ title: 'be cool' }, { title: nil }]
+        }
+      ]
+
+      expect(split[input]).to eql output
+    end
+
+    it 'splits a tuple into array fully by all subkeys' do
+      split = described_class.t(:split, :tasks, [:priority, :title])
+
+      output = [
+        { name: 'Joe', title: 'sleep well', priority: 1   },
+        { name: 'Joe', title: 'be nice',    priority: 2   },
+        { name: 'Joe', title: nil,          priority: 2   },
+        { name: 'Joe', title: 'be cool',    priority: nil },
+        { name: 'Joe', title: nil,          priority: nil }
+      ]
+
+      expect(split[input]).to eql output
+    end
+
+    it 'returns an array of one tuple with updated keys when there is nothing to split by' do
+      output = [
+        {
+          name: 'Joe',
+          tasks: [
+            { title: 'sleep well', priority: 1   },
+            { title: 'be nice',    priority: 2   },
+            { title: nil,          priority: 2   },
+            { title: 'be cool',    priority: nil },
+            { title: nil,          priority: nil }
+          ]
+        }
+      ]
+
+      split = described_class.t(:split, :tasks, [])
+      expect(split[input]).to eql output
+
+      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 = described_class.t(:split, :absent, [:priority, :title])
+      expect(split[input]).to eql [input]
+    end
+
+    it 'ignores empty array' do
+      input = { name: 'Joe', tasks: [] }
+
+      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
+
+  describe '.deep_merge' do
+    let(:hash) {
+      {
+        name: 'Jane',
+        email: 'jane@doe.org',
+        favorites:
+          {
+            food: 'stroopwafel'
+          }
+      }
+    }
+
+    let(:update) {
+      {
+        email: 'jane@example.org',
+        favorites:
+          {
+            color: 'orange'
+          }
+      }
+    }
+
+    it 'recursively merges hash values' do
+      deep_merge = described_class.t(:deep_merge)
+      output = {
+        name: 'Jane',
+        email: 'jane@example.org',
+        favorites: { food: 'stroopwafel', color: 'orange' }
+      }
+
+      expect(deep_merge[hash, update]).to eql(output)
+    end
+
+    it 'does not alter the provided arguments' do
+      original_hash = hash.dup
+      original_update = update.dup
+
+      described_class.t(:deep_merge)[hash, update]
+
+      expect(hash).to eql(original_hash)
+      expect(update).to eql(original_update)
+    end
+  end
+end