transproc 0.2.0 → 0.2.1

data/spec/{integration → unit}/coercions_spec.rb

@@ -1,25 +1,25 @@
 require 'spec_helper'
 
-describe 'Transproc / Coercions' do
-  describe 'to_string' do
+describe Transproc::Coercions do
+  describe '.to_string' do
     it 'turns integer into a string' do
       expect(t(:to_string)[1]).to eql('1')
     end
   end
 
-  describe 'to_symbol' do
+  describe '.to_symbol' do
     it 'turns string into a symbol' do
       expect(t(:to_symbol)['test']).to eql(:test)
     end
   end
 
-  describe 'to_integer' do
+  describe '.to_integer' do
     it 'turns string into an integer' do
       expect(t(:to_integer)['1']).to eql(1)
     end
   end
 
-  describe 'to_float' do
+  describe '.to_float' do
     it 'turns string into a float' do
       expect(t(:to_float)['1']).to eql(1.0)
     end
@@ -29,7 +29,7 @@ describe 'Transproc / Coercions' do
     end
   end
 
-  describe 'to_decimal' do
+  describe '.to_decimal' do
     it 'turns string into a decimal' do
       expect(t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
     end
@@ -43,28 +43,28 @@ describe 'Transproc / Coercions' do
     end
   end
 
-  describe 'to_date' do
+  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)
     end
   end
 
-  describe 'to_time' do
+  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)
     end
   end
 
-  describe 'to_datetime' do
+  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)
     end
   end
 
-  describe 'to_boolean' do
+  describe '.to_boolean' do
     subject(:coercer) { t(:to_boolean) }
 
     Transproc::Coercions::TRUE_VALUES.each do |value|

data/spec/{integration → unit}/conditional_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe 'Conditional transformations with Transproc' do
-  describe 'guard' do
+describe Transproc::Conditional do
+  describe '.guard' do
     let(:fn) { t(:guard, ->(value) { value.is_a?(::String) }, t(:to_integer)) }
 
     context 'when predicate returns truthy value' do

data/spec/{integration → unit}/function_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe "Transproc::Function" do
-  describe "#>>" do
-    it "composes named functions" do
+describe 'Transproc::Function' do
+  describe '#>>' do
+    it 'composes named functions' do
       f1 = t(:symbolize_keys)
       f2 = t(:rename_keys, user_name: :name)
 
@@ -12,7 +12,7 @@ describe "Transproc::Function" do
         [
           :symbolize_keys, [],
           [
-            :rename_keys, [ user_name: :name ]
+            :rename_keys, [user_name: :name]
           ]
         ]
       )
@@ -25,7 +25,7 @@ describe "Transproc::Function" do
         [
           :symbolize_keys, [],
           [
-            :rename_keys, [ user_name: :name ]
+            :rename_keys, [user_name: :name]
           ],
           [
             :nest, [:details, [:name]]
@@ -36,10 +36,10 @@ describe "Transproc::Function" do
       expect(f4['user_name' => 'Jane']).to eql(details: { name: 'Jane' })
     end
 
-    it "composes anonymous functions" do
+    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 { |v| v.to_s }
+      f2 = Transproc proc(&:to_s)
 
       f3 = f1 >> f2
 
@@ -52,5 +52,28 @@ 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))
+      f = t(: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
+      Transproc.register(:to_s, t(:to_string))
+      f = t(:to_s)
+
+      expect(f[:ok]).to eql('ok')
+      expect(f.to_ast).to eql([:to_string, []])
+    end
   end
 end

data/spec/{integration/hash_spec.rb → unit/hash_transformations_spec.rb}

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe 'Hash mapping with Transproc' do
-  describe 'map_keys' do
+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 })
 
@@ -13,7 +13,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_keys!' do
+  describe '.map_keys!' do
     it 'returns updated hash with given proc applied to keys' do
       map_keys = t(:map_keys!, ->(key) { key.strip })
 
@@ -25,7 +25,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'symbolize_keys' do
+  describe '.symbolize_keys' do
     it 'returns a new hash with symbolized keys' do
       symbolize_keys = t(:symbolize_keys)
 
@@ -37,7 +37,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'symbolize_keys!' do
+  describe '.symbolize_keys!' do
     it 'returns updated hash with symbolized keys' do
       symbolize_keys = t(:symbolize_keys!)
 
@@ -50,7 +50,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'stringify_keys' do
+  describe '.stringify_keys' do
     it 'returns a new hash with stringified keys' do
       stringify_keys = t(:stringify_keys)
 
@@ -62,7 +62,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'stringify_keys!' do
+  describe '.stringify_keys!' do
     it 'returns a new hash with stringified keys' do
       stringify_keys = t(:stringify_keys!)
 
@@ -74,7 +74,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_values' 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 })
 
@@ -86,7 +86,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_values!' do
+  describe '.map_values!' do
     it 'returns updated hash with given proc applied to values' do
       map_values = t(:map_values!, ->(value) { value.strip })
 
@@ -98,7 +98,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'rename_keys' do
+  describe '.rename_keys' do
     it 'returns a new hash with applied functions' do
       map = t(:rename_keys, 'foo' => :foo)
 
@@ -110,7 +110,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'rename_keys!' do
+  describe '.rename_keys!' do
     it 'returns updated hash with applied functions' do
       map = t(:rename_keys!, 'foo' => :foo)
 
@@ -123,7 +123,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_value' do
+  describe '.map_value' do
     it 'applies function to value under specified key' do
       transformation = t(:map_value, :user, t(:symbolize_keys))
 
@@ -135,7 +135,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_value!' do
+  describe '.map_value!' do
     it 'applies function to value under specified key' do
       transformation = t(:map_value!, :user, t(:symbolize_keys))
 
@@ -148,7 +148,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'nest' do
+  describe '.nest' do
     it 'returns new hash with keys nested under a new key' do
       nest = t(:nest, :baz, ['foo'])
 
@@ -160,7 +160,7 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'nest!' do
+  describe '.nest!' do
     it 'returns new hash with keys nested under a new key' do
       nest = t(:nest!, :baz, ['one', 'two', 'not-here'])
 
@@ -184,12 +184,12 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'unwrap!' do
+  describe '.unwrap!' do
     it 'returns updated hash with nested keys lifted to the root' do
-      unwrap = t(:unwrap!, 'wrapped', ['one', 'two'])
+      unwrap = t(:unwrap!, 'wrapped', %w(one))
 
       input = { 'foo' => 'bar', 'wrapped' => { 'one' => nil, 'two' => false } }
-      output = { 'foo' => 'bar', 'one' => nil, 'two' => false }
+      output = { 'foo' => 'bar', 'one' => nil, 'wrapped' => { 'two' => false } }
 
       unwrap[input]
 
@@ -208,18 +208,20 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'unwrap' do
+  describe '.unwrap' do
     it 'returns new hash with nested keys lifted to the root' do
-      unwrap = t(:unwrap, 'wrapped', ['one', 'two'])
+      unwrap = t(:unwrap, 'wrapped')
 
       input = {
         'foo' => 'bar',
         'wrapped' => { 'one' => nil, 'two' => false }
       }.freeze
 
-      expect(unwrap[input]).to eql({'foo' => 'bar',
-                                    'one' => nil,
-                                    'two' => false})
+      expect(unwrap[input]).to eql(
+        'foo' => 'bar',
+        'one' => nil,
+        'two' => false
+      )
     end
   end
 
@@ -252,4 +254,50 @@ describe 'Hash mapping with Transproc' do
       expect(result).to eql(output)
     end
   end
+
+  describe '.reject_keys!' do
+    it 'returns an updated hash with rejected keys' do
+      reject_keys = 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 = 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)
+      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 = 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
+
+  describe '.reject_keys' do
+    it 'returns a new hash with rejected keys' do
+      accept_keys = t(:accept_keys, [:age])
+
+      input = { name: 'Jane', email: 'jane@doe.org', age: 21 }
+      output = { age: 21 }
+
+      expect(accept_keys[input]).to eql(output)
+      expect(input).to eql(name: 'Jane', email: 'jane@doe.org', age: 21)
+    end
+  end
 end

data/spec/{integration → unit}/recursion_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
-describe 'Recursive transformations with Transproc' do
-  describe 'array_recursion' do
+describe Transproc::Recursion do
+  describe '.array_recursion' do
     let(:original) do
       [
         'foo',
@@ -29,16 +29,13 @@ describe 'Recursive transformations with Transproc' do
         [
           'foo',
           'bar',
-          [
-            'foo',
-            'bar'
-          ]
+          %w(foo bar)
         ]
       ]
     end
 
     context 'when function is non-destructive' do
-      let(:map) { t(:array_recursion, proc { |arr| arr.compact }) }
+      let(:map) { t(:array_recursion, proc(&:compact)) }
 
       it 'applies funtions to all items recursively' do
         expect(map[input]).to eql(output)
@@ -47,7 +44,7 @@ describe 'Recursive transformations with Transproc' do
     end
 
     context 'when function is destructive' do
-      let(:map) { t(:array_recursion, proc { |arr| arr.compact! }) }
+      let(:map) { t(:array_recursion, proc(&:compact!)) }
 
       it 'applies funtions to all items recursively and destructively' do
         expect(map[input]).to eql(output)
@@ -56,7 +53,7 @@ describe 'Recursive transformations with Transproc' do
     end
   end
 
-  describe 'hash_recursion' do
+  describe '.hash_recursion' do
     let(:original) do
       {
         'foo' => 'bar',

data/spec/unit/transproc_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe Transproc do
+  describe 'composition' do
+    it 'allows composing two transformation functions' do
+      input = '1'
+      output = 1.0
+
+      to_i = t(-> value { value.to_i })
+      to_f = t(-> value { value.to_f })
+
+      result = to_i >> to_f
+
+      expect(result[input]).to eql(output)
+    end
+  end
+
+  describe '.register' do
+    it 'allows registering functions by name' do
+      Transproc.register(:identity, -> value { value })
+
+      value = 'hello world'
+
+      result = t(:identity)[value]
+
+      expect(result).to be(value)
+    end
+
+    it 'allows registering function by passing a block' do
+      Transproc.register(:to_boolean1) { |value| value == 'true' }
+
+      result = t(-> value { value.to_s }) >> t(:to_boolean1)
+
+      expect(result[:true]).to be(true)
+      expect(result[:false]).to be(false)
+    end
+
+    it 'raises a Transproc::FunctionAlreadyRegisteredError if a function is already registered' do
+      Transproc.register(:bogus) {}
+      expect { Transproc.register(:bogus) {} }.to raise_error(Transproc::FunctionAlreadyRegisteredError)
+    end
+  end
+
+  describe 'nonextistent functions' do
+    it 'raises a Transproc::FunctionNotFoundError if asking for function that is non exsistent' do
+      expect {
+        Transproc(:i_do_not_exist)
+        raise('expected the :i_do_not_exist function to not exist')
+      }.to raise_error(Transproc::FunctionNotFoundError)
+    end
+  end
+
+  describe 'handling malformed input' do
+    it 'raises a Transproc::MalformedInputError' do
+      Transproc.register(:im_dangerous, ->(){
+        raise ArgumentError.new('sorry, you got some bad apples in your input')
+      })
+
+      expect{
+        Transproc(:im_dangerous)[hello: 'world']
+      }.to raise_error(Transproc::MalformedInputError)
+    end
+  end
+end