transproc 0.1.3 → 0.2.0

data/lib/transproc/recursion.rb

@@ -1,29 +1,70 @@
+require 'transproc/conditional'
+
 module Transproc
-  register(:array_recursion) do |value, fn|
-    result = fn[value]
-
-    result.map! do |item|
-      if item.is_a?(::Array)
-        Transproc(:array_recursion, fn)[item]
-      else
-        item
-      end
-    end
-  end
+  # Recursive transformation functions
+  #
+  # @example
+  #   require 'transproc/recursion'
+  #
+  #   include Transproc::Helper
+  #
+  #   fn = t(:hash_recursion, t(:symbolize_keys))
+  #
+  #   fn["name" => "Jane", "address" => { "street" => "Street 1", "zipcode" => "123" }]
+  #   # => {:name=>"Jane", :address=>{:street=>"Street 1", :zipcode=>"123"}}
+  #
+  # @api public
+  module Recursion
+    extend Functions
+
+    IF_ARRAY = -> fn { Transproc(:is, Array, fn) }
 
-  register(:hash_recursion) do |value, fn|
-    result = fn[value]
+    IF_HASH = -> fn { Transproc(:is, Hash, fn) }
 
-    result.keys.each do |key|
-      item = result.delete(key)
+    # Recursively apply the provided transformation function to an array
+    #
+    # @example
+    #   Transproc(:array_recursion, -> s { s.compact })[
+    #     [['Joe', 'Jane', nil], ['Smith', 'Doe', nil]]
+    #   ]
+    #   # =>  [["Joe", "Jane"], ["Smith", "Doe"]]
+    #
+    # @param [Array]
+    #
+    # @return [Array]
+    #
+    # @api public
+    def array_recursion(value, fn)
+      result = fn[value]
+      guarded = IF_ARRAY[-> v { Transproc(:array_recursion, fn)[v] }]
 
-      if item.is_a?(::Hash)
-        result[key] = Transproc(:hash_recursion, fn)[item]
-      else
-        result[key] = item
+      result.map! do |item|
+        guarded[item]
       end
     end
 
-    result
+    # Recursively apply the provided transformation function to a hash
+    #
+    # @example
+    #   Transproc(:hash_recursion, Transproc(:symbolize_keys))[
+    #     ["name" => "Jane", "address" => { "street" => "Street 1", "zipcode" => "123" }]
+    #   ]
+    #   # =>  {:name=>"Jane", :address=>{:street=>"Street 1", :zipcode=>"123"}}
+    #
+    # @param [Hash]
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def hash_recursion(value, fn)
+      result = fn[value]
+      guarded = IF_HASH[-> v { Transproc(:hash_recursion, fn)[v] }]
+
+      result.keys.each do |key|
+        result[key] = guarded[result.delete(key)]
+      end
+
+      result
+    end
   end
 end

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.2.0'.freeze
 end

data/spec/integration/array_spec.rb

@@ -56,8 +56,8 @@ describe 'Array transformations with Transproc' do
       wrap =
         t(
           :map_array,
-          t(:nest, :user, [:name, :title]),
-          t(:map_key, :user, t(:nest, :task, [:title]))
+          t(:nest, :user, [:name, :title]) +
+          t(:map_value, :user, t(:nest, :task, [:title]))
       )
 
       input = [{ name: 'Jane', title: 'One' }]

data/spec/integration/coercions_spec.rb

@@ -7,6 +7,12 @@ describe 'Transproc / Coercions' do
     end
   end
 
+  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
     it 'turns string into an integer' do
       expect(t(:to_integer)['1']).to eql(1)
@@ -61,13 +67,13 @@ describe 'Transproc / Coercions' do
   describe 'to_boolean' do
     subject(:coercer) { t(:to_boolean) }
 
-    Transproc::TRUE_VALUES.each do |value|
+    Transproc::Coercions::TRUE_VALUES.each do |value|
       it "turns #{value.inspect} to true" do
         expect(coercer[value]).to be(true)
       end
     end
 
-    Transproc::FALSE_VALUES.each do |value|
+    Transproc::Coercions::FALSE_VALUES.each do |value|
       it "turns #{value.inspect} to false" do
         expect(coercer[value]).to be(false)
       end

data/spec/integration/composer_spec.rb

@@ -8,7 +8,7 @@ describe Transproc::Composer do
       def fn
         compose do |fns|
           fns << t(:map_array, t(:symbolize_keys)) <<
-            t(:map_array, t(:map_key, :age, t(:to_integer)))
+            t(:map_array, t(:map_value, :age, t(:to_integer)))
         end
       end
     end.new

data/spec/integration/conditional_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe 'Conditional transformations with Transproc' do
+  describe 'guard' do
+    let(:fn) { t(:guard, ->(value) { value.is_a?(::String) }, 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/integration/function_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe "Transproc::Function" do
+  describe "#>>" do
+    it "composes named functions" do
+      f1 = t(:symbolize_keys)
+      f2 = t(: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 >> t(: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
+      # 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 }
+
+      f3 = f1 >> f2
+
+      expect(f3.to_ast).to eql(
+        [
+          f1.fn, [2],
+          [
+            f2.fn, []
+          ]
+        ]
+      )
+    end
+  end
+end

data/spec/integration/hash_spec.rb

@@ -1,6 +1,30 @@
 require 'spec_helper'
 
 describe 'Hash mapping with Transproc' 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 })
+
+      input = { ' foo ' => 'bar' }
+      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 = 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
+
   describe 'symbolize_keys' do
     it 'returns a new hash with symbolized keys' do
       symbolize_keys = t(:symbolize_keys)
@@ -26,6 +50,104 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
+  describe 'stringify_keys' do
+    it 'returns a new hash with stringified keys' do
+      stringify_keys = t(:stringify_keys)
+
+      input = { foo: 'bar' }
+      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 = t(:stringify_keys!)
+
+      input = { foo: 'bar' }
+      output = { 'foo' => 'bar' }
+
+      expect(stringify_keys[input]).to eql(output)
+      expect(input).to eql('foo' => 'bar')
+    end
+  end
+
+  describe 'map_values' do
+    it 'returns a new hash with given proc applied to values' do
+      map_values = 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
+
+  describe 'map_values!' do
+    it 'returns updated hash with given proc applied to values' do
+      map_values = 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
+
+  describe 'rename_keys' do
+    it 'returns a new hash with applied functions' do
+      map = t(:rename_keys, 'foo' => :foo)
+
+      input = { 'foo' => 'bar', :bar => 'baz' }
+      output = { foo: 'bar', bar: 'baz' }
+
+      expect(map[input]).to eql(output)
+      expect(input).to eql('foo' => 'bar', :bar => 'baz')
+    end
+  end
+
+  describe 'rename_keys!' do
+    it 'returns updated hash with applied functions' do
+      map = t(:rename_keys!, 'foo' => :foo)
+
+      input = { 'foo' => 'bar', :bar => 'baz' }
+      output = { foo: 'bar', bar: 'baz' }
+
+      map[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'map_value' do
+    it 'applies function to value under specified key' do
+      transformation = t(:map_value, :user, t(:symbolize_keys))
+
+      input = { user: { 'name' => 'Jane' } }
+      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 = t(:map_value!, :user, t(:symbolize_keys))
+
+      input = { user: { 'name' => 'Jane' } }
+      output = { user: { name: 'Jane' } }
+
+      transformation[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
   describe 'nest' do
     it 'returns new hash with keys nested under a new key' do
       nest = t(:nest, :baz, ['foo'])
@@ -101,60 +223,10 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
-  describe 'map_hash' do
-    it 'returns a new hash with applied functions' do
-      map = t(:map_hash, 'foo' => :foo)
-
-      input = { 'foo' => 'bar', :bar => 'baz' }
-      output = { foo: 'bar', bar: 'baz' }
-
-      expect(map[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar', :bar => 'baz')
-    end
-  end
-
-  describe 'map_hash!' do
-    it 'returns updated hash with applied functions' do
-      map = t(:map_hash!, 'foo' => :foo)
-
-      input = { 'foo' => 'bar', :bar => 'baz' }
-      output = { foo: 'bar', bar: 'baz' }
-
-      map[input]
-
-      expect(input).to eql(output)
-    end
-  end
-
-  describe 'map_key' do
-    it 'applies function to value under specified key' do
-      transformation = t(:map_key, :user, t(:symbolize_keys))
-
-      input = { user: { 'name' => 'Jane' } }
-      output = { user: { name: 'Jane' } }
-
-      expect(transformation[input]).to eql(output)
-      expect(input).to eql(user: { 'name' => 'Jane' })
-    end
-  end
-
-  describe 'map_key!' do
-    it 'applies function to value under specified key' do
-      transformation = t(:map_key!, :user, t(:symbolize_keys))
-
-      input = { user: { 'name' => 'Jane' } }
-      output = { user: { name: 'Jane' } }
-
-      transformation[input]
-
-      expect(input).to eql(output)
-    end
-  end
-
   describe 'nested transform' do
     it 'applies functions to nested hashes' do
       symbolize_keys = t(:symbolize_keys)
-      map_user_key = t(:map_key, :user, symbolize_keys)
+      map_user_key = t(:map_value, :user, symbolize_keys)
 
       transformation = symbolize_keys >> map_user_key
 
@@ -168,7 +240,7 @@ describe 'Hash mapping with Transproc' do
   describe 'combining transformations' do
     it 'applies functions to the hash' do
       symbolize_keys = t(:symbolize_keys)
-      map = t(:map_hash, user_name: :name, user_email: :email)
+      map = t(:rename_keys, user_name: :name, user_email: :email)
 
       transformation = symbolize_keys >> map
 

data/transproc.gemspec

@@ -8,9 +8,9 @@ Gem::Specification.new do |spec|
   spec.version       = Transproc::VERSION.dup
   spec.authors       = ["Piotr Solnica"]
   spec.email         = ["piotr.solnica@gmail.com"]
-  spec.summary       = %q{Experimental functional transformations for Ruby}
+  spec.summary       = %q{Transform Ruby objects in functional style}
   spec.description   = spec.summary
-  spec.homepage      = ""
+  spec.homepage      = "http://solnic.github.io/transproc/"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")