transproc 0.4.2 → 1.0.0

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.4.2'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/spec/spec_helper.rb

@@ -17,7 +17,3 @@ end
 
 root = Pathname(__FILE__).dirname
 Dir[root.join('support/*.rb').to_s].each { |f| require f }
-
-RSpec.configure do |config|
-  config.include(Transproc::Helper)
-end

data/spec/unit/array_transformations_spec.rb

@@ -7,45 +7,25 @@ describe Transproc::ArrayTransformations do
     it 'extracts values by key from all hashes' do
       extract_key = described_class.t(:extract_key, 'name')
 
-      original = [
-        { 'name' => 'Alice', 'role' => 'sender' },
-        { 'name' => 'Bob', 'role' => 'receiver' },
-        { 'role' => 'listener' }
-      ]
-
-      input = original
-
-      output = ['Alice', 'Bob', nil]
-
-      expect(extract_key[input]).to eql(output)
-      expect(input).to eql(original)
-    end
-  end
-
-  describe '.extract_key!' do
-    it 'extracts values by key from all hashes' do
-      extract_key = described_class.t(:extract_key!, 'name')
-
       input = [
         { 'name' => 'Alice', 'role' => 'sender' },
         { 'name' => 'Bob', 'role' => 'receiver' },
         { 'role' => 'listener' }
-      ]
+      ].freeze
 
       output = ['Alice', 'Bob', nil]
 
       expect(extract_key[input]).to eql(output)
-      expect(input).to eql(output)
     end
   end
 
+  it { expect(described_class).not_to be_contain(:extract_key!) }
+
   describe '.insert_key' do
     it 'wraps values to tuples with given key' do
       insert_key = described_class.t(:insert_key, 'name')
 
-      original = ['Alice', 'Bob', nil]
-
-      input = original
+      input = ['Alice', 'Bob', nil].freeze
 
       output = [
         { 'name' => 'Alice' },
@@ -54,36 +34,16 @@ describe Transproc::ArrayTransformations do
       ]
 
       expect(insert_key[input]).to eql(output)
-      expect(input).to eql(original)
     end
   end
 
-  describe '.insert_key!' do
-    it 'wraps values to tuples with given key' do
-      insert_key = described_class.t(:insert_key!, 'name')
-
-      original = ['Alice', 'Bob', nil]
-
-      input = original
-
-      output = [
-        { 'name' => 'Alice' },
-        { 'name' => 'Bob' },
-        { 'name' => nil }
-      ]
-
-      expect(insert_key[input]).to eql(output)
-      expect(input).to eql(output)
-    end
-  end
+  it { expect(described_class).not_to be_contain(:insert_key!) }
 
   describe '.add_keys' do
     it 'returns a new array with missed keys added to tuples' do
       add_keys = described_class.t(:add_keys, [:foo, :bar, :baz])
 
-      original = [{ foo: 'bar' }, { bar: 'baz' }]
-
-      input = original
+      input = [{ foo: 'bar' }, { bar: 'baz' }].freeze
 
       output = [
         { foo: 'bar', bar: nil, baz: nil },
@@ -91,38 +51,19 @@ describe Transproc::ArrayTransformations do
       ]
 
       expect(add_keys[input]).to eql(output)
-      expect(input).to eql(original)
     end
   end
 
-  describe '.add_keys!' do
-    it 'adds missed keys to tuples' do
-      add_keys = described_class.t(:add_keys!, [:foo, :bar, :baz])
-
-      original = [{ foo: 'bar' }, { bar: 'baz' }]
-
-      input = original
-
-      output = [
-        { foo: 'bar', bar: nil, baz: nil },
-        { foo: nil, bar: 'baz', baz: nil }
-      ]
-
-      expect(add_keys[input]).to eql(output)
-      expect(input).to eql(output)
-    end
-  end
+  it { expect(described_class).not_to be_contain(:add_keys!) }
 
   describe '.map_array' do
     it 'applies funtions to all values' do
       map = described_class.t(:map_array, hashes[:symbolize_keys])
 
-      original = [
-        { 'name' => 'Jane', 'title' => 'One' },
-        { 'name' => 'Jane', 'title' => 'Two' }
-      ]
-
-      input = original
+      input = [
+        { 'name' => 'Jane', 'title' => 'One' }.freeze,
+        { 'name' => 'Jane', 'title' => 'Two' }.freeze
+      ].freeze
 
       output = [
         { name: 'Jane', title: 'One' },
@@ -130,38 +71,25 @@ describe Transproc::ArrayTransformations do
       ]
 
       expect(map[input]).to eql(output)
-      expect(input).to eql(original)
     end
 
     it 'handles huge arrays' do
       map = described_class.t(:map_array, hashes[:symbolize_keys])
 
-      input = 138706.times.map { |i| { 'key' => i } }
+      input = Array.new(138_706) { |i| { 'key' => i } }
 
-      expect { map[input] }.to_not raise_error(SystemStackError, /stack level too deep/)
+      expect { map[input] }.to_not raise_error
     end
-  end
-
-  describe '.map_array!' do
-    it 'updates array with the result of the function applied to each value' do
-      map = described_class.t(:map_array!, hashes[:symbolize_keys])
-
-      input = [
-        { 'name' => 'Jane', 'title' => 'One' },
-        { 'name' => 'Jane', 'title' => 'Two' }
-      ]
 
-      output = [
-        { name: 'Jane', title: 'One' },
-        { name: 'Jane', title: 'Two' }
-      ]
-
-      map[input]
+    it 'handles flat value arrays' do
+      map = described_class.t(:map_array, :upcase.to_proc)
 
-      expect(input).to eql(output)
+      expect(map['foo']).to eql(%w(FOO))
     end
   end
 
+  it { expect(described_class).not_to be_contain(:map_array!) }
+
   describe '.wrap' do
     it 'returns a new array with wrapped hashes' do
       wrap = described_class.t(:wrap, :task, [:title])

data/spec/unit/function_not_found_error_spec.rb

@@ -1,15 +1,7 @@
 # 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
+  it 'complains that the function not registered' do
     Foo = Module.new { extend Transproc::Registry }
 
     expect { Foo[:foo] }.to raise_error do |error|

data/spec/unit/function_spec.rb

@@ -1,13 +1,19 @@
 require 'spec_helper'
 
 describe Transproc::Function do
-  let(:hashes) { Transproc::HashTransformations }
+  let(:container) do
+    Module.new do
+      extend Transproc::Registry
+
+      import Transproc::HashTransformations
+    end
+  end
 
   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
+      expect(container[:symbolize_keys].name).to eql :symbolize_keys
     end
 
     it 'returns the explicitly assigned name' do
@@ -21,8 +27,8 @@ describe Transproc::Function do
 
   describe '#>>' do
     it 'composes named functions' do
-      f1 = hashes[:symbolize_keys]
-      f2 = hashes[:rename_keys, user_name: :name]
+      f1 = container[:symbolize_keys]
+      f2 = container[:rename_keys, user_name: :name]
 
       f3 = f1 >> f2
 
@@ -37,7 +43,7 @@ describe Transproc::Function do
 
       expect(f3['user_name' => 'Jane']).to eql(name: 'Jane')
 
-      f4 = f3 >> hashes[:nest, :details, [:name]]
+      f4 = f3 >> container[:nest, :details, [:name]]
 
       expect(f4.to_ast).to eql(
         [
@@ -55,9 +61,8 @@ describe Transproc::Function do
     end
 
     it 'composes anonymous functions' do
-      # TODO: Use Transproc -> (v) { v.to_s } after release of jruby-9k
-      f1 = Transproc proc { |v, m| v * m }, 2
-      f2 = Transproc proc(&:to_s)
+      f1 = container[->(v, m) { v * m }, 2]
+      f2 = container[:to_s.to_proc]
 
       f3 = f1 >> f2
 
@@ -72,8 +77,8 @@ describe Transproc::Function do
     end
 
     it 'plays well with registered compositions' do
-      Transproc.register(:user_names, hashes[:symbolize_keys] + hashes[:rename_keys, user_name: :name])
-      f = t(:user_names)
+      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(
@@ -87,8 +92,8 @@ describe Transproc::Function do
     end
 
     it 'plays well with registered functions' do
-      Transproc.register(:to_s, t(:to_string))
-      fn = t(:to_s)
+      container.register(:to_string, Transproc::Coercions.t(:to_string))
+      fn = container.t(:to_string)
 
       expect(fn[:ok]).to eql('ok')
       expect(fn.to_ast).to eql([:to_string, []])

data/spec/unit/hash_transformations_spec.rb

@@ -1,40 +1,27 @@
 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 = described_class.t(:map_keys, ->(key) { key.strip })
 
-      input = { ' foo ' => 'bar' }
+      input = { ' foo ' => 'bar' }.freeze
       output = { 'foo' => 'bar' }
 
       expect(map_keys[input]).to eql(output)
-      expect(input).to eql(' foo ' => 'bar')
     end
   end
 
-  describe '.map_keys!' do
-    it 'returns updated hash with given proc applied to keys' do
-      map_keys = described_class.t(:map_keys!, ->(key) { key.strip })
-
-      input = { ' foo ' => 'bar' }
-      output = { 'foo' => 'bar' }
-
-      expect(map_keys[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar')
-    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' }
+      input = { 1 => 'bar' }.freeze
       output = { '1'.to_sym => 'bar' }
 
       expect(symbolize_keys[input]).to eql(output)
-      expect { symbolize_keys[input] }.not_to change { input }
     end
   end
 
@@ -50,111 +37,65 @@ describe Transproc::HashTransformations do
     end
   end
 
-  describe '.symbolize_keys!' do
-    it 'returns updated hash with symbolized keys' do
-      symbolize_keys = described_class.t(:symbolize_keys!)
-
-      input = { 'foo' => 'bar' }
-      output = { foo: 'bar' }
-
-      symbolize_keys[input]
-
-      expect(input).to eql(output)
-    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' }
+      input = { foo: 'bar' }.freeze
       output = { 'foo' => 'bar' }
 
       expect(stringify_keys[input]).to eql(output)
-      expect(input).to eql(foo: 'bar')
     end
   end
 
-  describe '.stringify_keys!' do
-    it 'returns a new hash with stringified keys' do
-      stringify_keys = described_class.t(:stringify_keys!)
-
-      input = { foo: 'bar' }
-      output = { 'foo' => 'bar' }
-
-      expect(stringify_keys[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar')
-    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 ' }
+      input = { 'foo' => ' bar ' }.freeze
       output = { 'foo' => 'bar' }
 
       expect(map_values[input]).to eql(output)
-      expect(input).to eql('foo' => ' bar ')
     end
   end
 
-  describe '.map_values!' do
-    it 'returns updated hash with given proc applied to values' do
-      map_values = described_class.t(:map_values!, ->(value) { value.strip })
-
-      input = { 'foo' => ' bar ' }
-      output = { 'foo' => 'bar' }
-
-      expect(map_values[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar')
-    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' }
+      input = { 'foo' => 'bar', :bar => 'baz' }.freeze
       output = { foo: 'bar', bar: 'baz' }
 
       expect(map[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar', :bar => 'baz')
     end
 
-    it "only renames keys and never creates new ones" do
+    it 'only renames keys and never creates new ones' do
       map = described_class.t(:rename_keys, 'foo' => :foo, 'bar' => :bar)
 
-      input = { 'bar' => 'baz' }
+      input = { 'bar' => 'baz' }.freeze
       output = { bar: 'baz' }
 
       expect(map[input]).to eql(output)
-      expect(input).to eql('bar' => 'baz')
     end
   end
 
-  describe '.rename_keys!' do
-    it 'returns updated hash with applied functions' do
-      map = described_class.t(:rename_keys!, 'foo' => :foo)
+  it { expect(described_class).not_to be_contain(:rename_keys!) }
 
-      input = { 'foo' => 'bar', :bar => 'baz' }
-      output = { foo: 'bar', bar: 'baz' }
-
-      map[input]
-
-      expect(input).to eql(output)
-    end
-  end
   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' }
+        input = { 'foo' => 'bar', :bar => 'baz' }.freeze
         output = { 'foo' => 'bar', foo: 'bar', bar: 'baz' }
 
         expect(map[input]).to eql(output)
-        expect(input).to eql('foo' => 'bar', :bar => 'baz')
       end
     end
 
@@ -162,202 +103,127 @@ describe Transproc::HashTransformations do
       it 'returns a new hash with applied functions' do
         map = described_class.t(:copy_keys, 'foo' => [:foo, :baz])
 
-        input = { 'foo' => 'bar', :bar => 'baz' }
+        input = { 'foo' => 'bar', :bar => 'baz' }.freeze
         output = { 'foo' => 'bar', foo: 'bar', baz: 'bar', bar: 'baz' }
 
         expect(map[input]).to eql(output)
-        expect(input).to eql('foo' => 'bar', :bar => 'baz')
       end
     end
   end
 
-  describe '.copy_keys!' do
-    context 'with single destination key' do
-      it 'returns updated hash with applied functions' do
-        map = described_class.t(:copy_keys!, 'foo' => :foo)
-
-        input = { 'foo' => 'bar', :bar => 'baz' }
-        output = { 'foo' => 'bar', foo: 'bar', bar: 'baz' }
-
-        map[input]
-
-        expect(input).to eql(output)
-      end
-    end
-
-    context 'with multiple destination keys' do
-      it 'returns updated hash with applied functions' do
-        map = described_class.t(:copy_keys!, 'foo' => [:foo, :baz])
-
-        input = { 'foo' => 'bar', :bar => 'baz' }
-        output = { 'foo' => 'bar', foo: 'bar', baz: 'bar', bar: 'baz' }
-
-        map[input]
-
-        expect(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' } }
+      input = { user: { 'name' => 'Jane' }.freeze }.freeze
       output = { user: { name: 'Jane' } }
 
       expect(transformation[input]).to eql(output)
-      expect(input).to eql(user: { 'name' => 'Jane' })
     end
   end
 
-  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' } }
-      output = { user: { name: 'Jane' } }
-
-      transformation[input]
-
-      expect(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' }
+      input = { 'foo' => 'bar' }.freeze
       output = { baz: { 'foo' => 'bar' } }
 
       expect(nest[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar')
-    end
-  end
-
-  describe '.nest!' do
-    it 'returns new hash with keys nested under a new key' do
-      nest = described_class.t(:nest!, :baz, %w(one two not-here))
-
-      input = { 'foo' => 'bar', 'one' => nil, 'two' => false }
-      output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
-
-      nest[input]
-
-      expect(input).to eql(output)
     end
 
     it 'returns new hash with keys nested under the existing key' do
-      nest = described_class.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 } }
+      input = {
+        'foo' => 'bar',
+        baz: { 'one' => nil }.freeze,
+        'two' => false
+      }.freeze
 
-      nest[input]
+      output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
 
-      expect(input).to eql(output)
+      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'])
+      nest = described_class.t(:nest, :baz, ['two'])
 
-      input  = { 'foo' => 'bar', baz: 'one', 'two' => false }
+      input  = { 'foo' => 'bar', baz: 'one', 'two' => false }.freeze
       output = { 'foo' => 'bar', baz: { 'two' => false } }
 
-      nest[input]
-
-      expect(input).to eql(output)
+      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'])
+      nest = described_class.t(:nest, :baz, ['foo'])
 
-      input = { 'bar' => 'foo' }
+      input = { 'bar' => 'foo' }.freeze
       output = { 'bar' => 'foo', baz: {} }
 
-      nest[input]
-
-      expect(input).to eql(output)
+      expect(nest[input]).to eql(output)
     end
   end
 
-  describe '.unwrap!' do
-    it 'returns updated hash with nested keys lifted to the root' do
-      unwrap = described_class.t(:unwrap!, 'wrapped', %w(one))
+  it { expect(described_class).not_to be_contain(:nest!) }
 
-      input = { 'foo' => 'bar', 'wrapped' => { 'one' => nil, 'two' => false } }
-      output = { 'foo' => 'bar', 'one' => nil, 'wrapped' => { 'two' => false } }
+  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
 
-      unwrap[input]
+      output = { 'foo' => 'bar', 'one' => nil, 'wrapped' => { 'two' => false } }
 
-      expect(input).to eql(output)
+      expect(unwrap[input]).to eql(output)
     end
 
     it 'lifts all keys if none are passed' do
-      unwrap = described_class.t(:unwrap!, 'wrapped')
+      unwrap = described_class.t(:unwrap, 'wrapped')
 
-      input = { 'wrapped' => { 'one' => nil, 'two' => false } }
+      input = { 'wrapped' => { 'one' => nil, 'two' => false }.freeze }.freeze
       output = { 'one' => nil, 'two' => false }
 
-      unwrap[input]
-
-      expect(input).to eql(output)
+      expect(unwrap[input]).to eql(output)
     end
 
     it 'ignores unknown keys' do
-      unwrap = described_class.t(:unwrap!, 'wrapped', %w(one two three))
+      unwrap = described_class.t(:unwrap, 'wrapped', %w(one two three))
 
-      input = { 'wrapped' => { 'one' => nil, 'two' => false } }
+      input = { 'wrapped' => { 'one' => nil, 'two' => false }.freeze }.freeze
       output = { 'one' => nil, 'two' => false }
 
-      unwrap[input]
-
-      expect(input).to eql(output)
+      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)
+      unwrap = described_class.t(:unwrap, 'wrapped', prefix: true)
 
-      input = { 'wrapped' => { one: nil, two: false } }
+      input = { 'wrapped' => { one: nil, two: false }.freeze }.freeze
       output = { 'wrapped_one' => nil, 'wrapped_two' => false }
 
-      unwrap[input]
-
-      expect(input).to eql(output)
+      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)
+      unwrap = described_class.t(:unwrap, :wrapped, prefix: true)
 
-      input = { wrapped: { 'one' => nil, 'two' => false } }
+      input = { wrapped: { 'one' => nil, 'two' => false }.freeze }.freeze
       output = { wrapped_one: nil, wrapped_two: false }
 
-      unwrap[input]
-
-      expect(input).to eql(output)
+      expect(unwrap[input]).to eql(output)
     end
   end
 
-  describe '.unwrap' do
-    it 'returns new hash with nested keys lifted to the root' do
-      unwrap = described_class.t(:unwrap, 'wrapped')
-
-      input = {
-        'foo' => 'bar',
-        'wrapped' => { 'one' => nil, 'two' => false }
-      }.freeze
-
-      expect(unwrap[input]).to eql(
-        'foo' => 'bar',
-        'one' => nil,
-        'two' => false
-      )
-    end
-  end
+  it { expect(described_class).not_to be_contain(:unwrap!) }
 
   describe 'nested transform' do
     it 'applies functions to nested hashes' do
@@ -389,90 +255,62 @@ describe Transproc::HashTransformations do
     end
   end
 
-  describe '.reject_keys!' do
-    it 'returns an updated hash with rejected keys' do
-      reject_keys = described_class.t(:reject_keys, [:name, :age])
-
-      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
-      output = { email: 'jane@doe.org' }
-
-      expect(reject_keys[input]).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 }
+      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }.freeze
       output = { email: 'jane@doe.org' }
 
       expect(reject_keys[input]).to eql(output)
-      expect(input).to eql(name: 'Jane', email: 'jane@doe.org', age: 21)
     end
   end
 
-  describe '.accept_keys!' do
-    it 'returns an updated hash with accepted keys' do
-      accept_keys = described_class.t(:accept_keys, [:age])
-
-      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
-      output = { age: 21 }
-
-      expect(accept_keys[input]).to eql(output)
-    end
-  end
+  it { expect(described_class).not_to be_contain(:reject_keys!) }
 
-  describe '.reject_keys' do
+  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 }
+      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }.freeze
       output = { age: 21 }
 
       expect(accept_keys[input]).to eql(output)
-      expect(input).to eql(name: 'Jane', email: 'jane@doe.org', age: 21)
     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 }, { title: 'sleep well' }]
-      }
+        tasks: [
+          { title: 'be nice', priority: 1 }.freeze,
+          { title: 'sleep well' }.freeze
+        ].freeze
+      }.freeze
     end
 
-    it_behaves_like :transforming_immutable_data do
-      let(:arguments) { [:fold, :tasks, :title] }
-      let(:output)    { { name: 'Jane', tasks: ['be nice', 'sleep well'] } }
-    end
+    it 'returns a new hash with folded values' do
+      fold = described_class.t(:fold, :tasks, :title)
 
-    it_behaves_like :transforming_immutable_data do
-      let(:arguments) { [:fold, :tasks, :priority] }
-      let(:output)    { { name: 'Jane', tasks: [1, nil] } }
-    end
-  end
+      output = { name: 'Jane', tasks: ['be nice', 'sleep well'] }
 
-  describe '.fold!' do
-    let(:input) do
-      {
-        name: 'Jane',
-        tasks: [{ title: 'be nice', priority: 1 }, { title: 'sleep well' }]
-      }
+      expect(fold[input]).to eql(output)
     end
 
-    it_behaves_like :mutating_input_data do
-      let(:arguments) { [:fold!, :tasks, :title] }
-      let(:output)    { { name: 'Jane', tasks: ['be nice', 'sleep well'] } }
-    end
+    it 'uses nil if there was not such attribute' do
+      fold = described_class.t(:fold, :tasks, :priority)
 
-    it_behaves_like :mutating_input_data do
-      let(:arguments) { [:fold!, :tasks, :priority] }
-      let(:output)    { { name: 'Jane', tasks: [1, nil] } }
+      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
       {