transproc 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e48e0386ec7eb3b18878b0a49f7aa292eceaf95
-  data.tar.gz: 8add522072d758b21a1bdcdacd038e074e276656
+  metadata.gz: b43b407d9915f16f63dbf1a12f10c9a87228213c
+  data.tar.gz: a46a7614a839a50da267593eeef25acbc8db167b
 SHA512:
-  metadata.gz: ec69053a3c644da6e9681ff45e7f61c19a843ca2d7d3bca3678ee6afbca25685c9c503852e634bdcefadffb3fc67b61311785fe95ca2e3b0b10e6a335616779d
-  data.tar.gz: 1d379f5fa10fc373a2f3d56d5ffc2392189c93fc184f09c9fcb992b912418655e3cc11f2da223b5463b328dfea878981b439409d32a1ffe9498630668044006e
+  metadata.gz: 5ce15554b0639b3c79a0a4da686e588f01dd0de7798b89a7129c39b0a51f0f0c31b094533775b3b21f5b6b893917020f2d99aa1b84648c445617c75f3f8e5688
+  data.tar.gz: 104618d775a9ce9781583b2c6f4e0e61ca28107f1f4494124b41456c8442b4663a7d4ad5b353dd6641b0e885f56d5b33ee0d0a32e23ff5a6ad4c9fcf2f029e96

data/.gitignore

@@ -1,6 +1,7 @@
 /.bundle/
 /.yardoc
 /Gemfile.lock
+/vendor/
 /_yardoc/
 /coverage/
 /doc/

data/.travis.yml

@@ -1,4 +1,6 @@
 language: ruby
+sudo: false
+cache: bundler
 env:
   - CODECLIMATE_REPO_TOKEN=aead71de2239048f830499462c54b57dfc646f1d56ad5dcbbc3469a6ebaf97ca
 script: "bundle exec rake spec"

data/CHANGELOG.md

@@ -1,3 +1,16 @@
+## v0.1.3 to-be-released
+
+### Added
+
+* Added `hash_recursion` and `array_recursion` functions (AMHOL)
+* Added `unwrap` and `unwrap!` functions (aflatter)
+
+### Changed
+
+* Speedup transproc `group` (splattael)
+
+[Compare v0.1.2...v0.1.3](https://github.com/solnic/transproc/compare/v0.1.2...v0.1.3)
+
 ## v0.1.2 2015-03-14
 
 ### Changed

data/README.md

@@ -39,7 +39,7 @@ Or install it yourself as:
 require 'transproc/all'
 
 # compose transformation functions
-transformation = Transproc(:symbolize_keys) + Transproc(:map_hash, user_name: :name))
+transformation = Transproc(:symbolize_keys) >> Transproc(:map_hash, user_name: :name))
 
 # call the function
 transformation['user_name' => 'Jane']

data/lib/transproc/all.rb

@@ -3,3 +3,4 @@ require 'transproc'
 require 'transproc/coercions'
 require 'transproc/array'
 require 'transproc/hash'
+require 'transproc/recursion'

data/lib/transproc/array.rb

@@ -13,17 +13,15 @@ module Transproc
   end
 
   register(:group) do |array, key, keys|
-    names = nil
-
-    array
-      .group_by { |hash|
-        names ||= hash.keys - keys
-        Hash[names.zip(hash.values_at(*names))]
-      }
-      .map { |root, children|
-        children.map! { |child| Hash[keys.zip(child.values_at(*keys))] }
-        children.select! { |child| child.values.any? }
-        root.merge(key => children)
-      }
+    grouped = Hash.new { |hash, key| hash[key] = [] }
+    array.each do |hash|
+      hash = hash.dup
+      child = {}
+      keys.each { |k| child[k] = hash.delete(k) }
+      grouped[hash] << child
+    end
+    grouped.map do |root, children|
+      root.merge(key => children)
+    end
   end
 end

data/lib/transproc/composer.rb

@@ -1,5 +1,12 @@
 module Transproc
+  module Helper
+    def t(*args, &block)
+      Transproc(*args, &block)
+    end
+  end
+
   module Composer
+    include Helper
 
     class Factory
       attr_reader :fns, :default
@@ -19,15 +26,10 @@ module Transproc
       end
     end
 
-    def t(*args)
-      Transproc(*args)
-    end
-
     def compose(default = nil)
       factory = Factory.new(default)
       yield(factory)
       factory.to_fn
     end
-
   end
 end

data/lib/transproc/function.rb

@@ -13,8 +13,9 @@ module Transproc
     alias_method :[], :call
 
     def compose(other)
-      self.class.new(-> *result { other[fn[*result]] }, args)
+      self.class.new(-> *input { other[fn[*input]] }, args)
     end
     alias_method :+, :compose
+    alias_method :>>, :compose
   end
 end

data/lib/transproc/hash.rb

@@ -39,4 +39,19 @@ module Transproc
       hash.update(root => {})
     end
   end
+
+  register(:unwrap) do |hash, root, keys|
+    copy = Hash[hash].merge(root => Hash[hash[root]])
+    Transproc(:unwrap!, root, keys)[copy]
+  end
+
+  register(:unwrap!) do |hash, root, keys|
+    if nested_hash = hash[root]
+      keys ||= nested_hash.keys
+      hash.update(Hash[keys.zip(keys.map { |key| nested_hash.delete(key) })])
+      hash.delete(root) if nested_hash.empty?
+    end
+
+    hash
+  end
 end

data/lib/transproc/recursion.rb

@@ -0,0 +1,29 @@
+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
+
+  register(:hash_recursion) do |value, fn|
+    result = fn[value]
+
+    result.keys.each do |key|
+      item = result.delete(key)
+
+      if item.is_a?(::Hash)
+        result[key] = Transproc(:hash_recursion, fn)[item]
+      else
+        result[key] = item
+      end
+    end
+
+    result
+  end
+end

data/lib/transproc/version.rb

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

data/spec/integration/array_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Array transformations with Transproc' do
   describe 'map_array' do
     it 'applies funtions to all values' do
-      map = Transproc(:map_array, Transproc(:symbolize_keys))
+      map = t(:map_array, t(:symbolize_keys))
 
       original = [
         { 'name' => 'Jane', 'title' => 'One' },
@@ -24,7 +24,7 @@ describe 'Array transformations with Transproc' do
 
   describe 'map_array!' do
     it 'updates array with the result of the function applied to each value' do
-      map = Transproc(:map_array!, Transproc(:symbolize_keys))
+      map = t(:map_array!, t(:symbolize_keys))
 
       input = [
         { 'name' => 'Jane', 'title' => 'One' },
@@ -44,7 +44,7 @@ describe 'Array transformations with Transproc' do
 
   describe 'wrap' do
     it 'returns a new array with wrapped hashes' do
-      wrap = Transproc(:wrap, :task, [:title])
+      wrap = t(:wrap, :task, [:title])
 
       input = [{ name: 'Jane', title: 'One' }]
       output = [{ name: 'Jane', task: { title: 'One' } }]
@@ -54,10 +54,10 @@ describe 'Array transformations with Transproc' do
 
     it 'returns a array new with deeply wrapped hashes' do
       wrap =
-        Transproc(
+        t(
           :map_array,
-          Transproc(:nest, :user, [:name, :title]),
-          Transproc(:map_key, :user, Transproc(:nest, :task, [:title]))
+          t(:nest, :user, [:name, :title]),
+          t(:map_key, :user, t(:nest, :task, [:title]))
       )
 
       input = [{ name: 'Jane', title: 'One' }]
@@ -69,7 +69,7 @@ describe 'Array transformations with Transproc' do
 
   describe 'group' do
     it 'returns a new array with grouped hashes' do
-      group = Transproc(:group, :tasks, [:title])
+      group = t(:group, :tasks, [:title])
 
       input = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
       output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
@@ -80,8 +80,8 @@ describe 'Array transformations with Transproc' do
 
   describe 'composition' do
     it 'allows composing transformations' do
-      map = Transproc(:map_array, Transproc(:symbolize_keys))
-      group = Transproc(:group, :tasks, [:title])
+      map = t(:map_array, t(:symbolize_keys))
+      group = t(:group, :tasks, [:title])
 
       input = [
         { 'name' => 'Jane', 'title' => 'One' },
@@ -90,7 +90,7 @@ describe 'Array transformations with Transproc' do
 
       output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
 
-      transformation = map + group
+      transformation = map >> group
 
       expect(transformation[input]).to eql(output)
     end

data/spec/integration/coercions_spec.rb

@@ -3,63 +3,63 @@ require 'spec_helper'
 describe 'Transproc / Coercions' do
   describe 'to_string' do
     it 'turns integer into a string' do
-      expect(Transproc(:to_string)[1]).to eql('1')
+      expect(t(:to_string)[1]).to eql('1')
     end
   end
 
   describe 'to_integer' do
     it 'turns string into an integer' do
-      expect(Transproc(:to_integer)['1']).to eql(1)
+      expect(t(:to_integer)['1']).to eql(1)
     end
   end
 
   describe 'to_float' do
     it 'turns string into a float' do
-      expect(Transproc(:to_float)['1']).to eql(1.0)
+      expect(t(:to_float)['1']).to eql(1.0)
     end
 
     it 'turns integer into a float' do
-      expect(Transproc(:to_float)[1]).to eql(1.0)
+      expect(t(:to_float)[1]).to eql(1.0)
     end
   end
 
   describe 'to_decimal' do
     it 'turns string into a decimal' do
-      expect(Transproc(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
+      expect(t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
     end
 
     it 'turns float into a decimal' do
-      expect(Transproc(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
+      expect(t(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
     end
 
     it 'turns integer into a decimal' do
-      expect(Transproc(:to_decimal)[1]).to eql(BigDecimal('1.0'))
+      expect(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(Transproc(:to_date)['18th, November 1983']).to eql(date)
+      expect(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(Transproc(:to_time)['2012-01-23 11:07:07']).to eql(time)
+      expect(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(Transproc(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
+      expect(t(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
     end
   end
 
   describe 'to_boolean' do
-    subject(:coercer) { Transproc(:to_boolean) }
+    subject(:coercer) { t(:to_boolean) }
 
     Transproc::TRUE_VALUES.each do |value|
       it "turns #{value.inspect} to true" do

data/spec/integration/hash_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe 'Hash mapping with Transproc' do
   describe 'symbolize_keys' do
     it 'returns a new hash with symbolized keys' do
-      symbolize_keys = Transproc(:symbolize_keys)
+      symbolize_keys = t(:symbolize_keys)
 
       input = { 'foo' => 'bar' }
       output = { foo: 'bar' }
@@ -15,7 +15,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'symbolize_keys!' do
     it 'returns updated hash with symbolized keys' do
-      symbolize_keys = Transproc(:symbolize_keys!)
+      symbolize_keys = t(:symbolize_keys!)
 
       input = { 'foo' => 'bar' }
       output = { foo: 'bar' }
@@ -28,7 +28,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'nest' do
     it 'returns new hash with keys nested under a new key' do
-      nest = Transproc(:nest, :baz, ['foo'])
+      nest = t(:nest, :baz, ['foo'])
 
       input = { 'foo' => 'bar' }
       output = { baz: { 'foo' => 'bar' } }
@@ -40,7 +40,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'nest!' do
     it 'returns new hash with keys nested under a new key' do
-      nest = Transproc(:nest!, :baz, ['one', 'two', 'not-here'])
+      nest = t(:nest!, :baz, ['one', 'two', 'not-here'])
 
       input = { 'foo' => 'bar', 'one' => nil, 'two' => false }
       output = { 'foo' => 'bar', baz: { 'one' => nil, 'two' => false } }
@@ -51,7 +51,7 @@ describe 'Hash mapping with Transproc' do
     end
 
     it 'returns new hash with an empty hash under a new key when nest-keys are missing' do
-      nest = Transproc(:nest!, :baz, ['foo'])
+      nest = t(:nest!, :baz, ['foo'])
 
       input = { 'bar' => 'foo' }
       output = { 'bar' => 'foo', baz: {} }
@@ -62,9 +62,48 @@ describe 'Hash mapping with Transproc' do
     end
   end
 
+  describe 'unwrap!' do
+    it 'returns updated hash with nested keys lifted to the root' do
+      unwrap = t(:unwrap!, 'wrapped', ['one', 'two'])
+
+      input = { 'foo' => 'bar', 'wrapped' => { 'one' => nil, 'two' => false } }
+      output = { 'foo' => 'bar', 'one' => nil, 'two' => false }
+
+      unwrap[input]
+
+      expect(input).to eql(output)
+    end
+
+    it 'lifts all keys if none are passed' do
+      unwrap = t(:unwrap!, 'wrapped')
+
+      input = { 'wrapped' => { 'one' => nil, 'two' => false } }
+      output = { 'one' => nil, 'two' => false }
+
+      unwrap[input]
+
+      expect(input).to eql(output)
+    end
+  end
+
+  describe 'unwrap' do
+    it 'returns new hash with nested keys lifted to the root' do
+      unwrap = t(:unwrap, 'wrapped', ['one', 'two'])
+
+      input = {
+        'foo' => 'bar',
+        'wrapped' => { 'one' => nil, 'two' => false }
+      }.freeze
+
+      expect(unwrap[input]).to eql({'foo' => 'bar',
+                                    'one' => nil,
+                                    'two' => false})
+    end
+  end
+
   describe 'map_hash' do
     it 'returns a new hash with applied functions' do
-      map = Transproc(:map_hash, 'foo' => :foo)
+      map = t(:map_hash, 'foo' => :foo)
 
       input = { 'foo' => 'bar', :bar => 'baz' }
       output = { foo: 'bar', bar: 'baz' }
@@ -76,7 +115,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'map_hash!' do
     it 'returns updated hash with applied functions' do
-      map = Transproc(:map_hash!, 'foo' => :foo)
+      map = t(:map_hash!, 'foo' => :foo)
 
       input = { 'foo' => 'bar', :bar => 'baz' }
       output = { foo: 'bar', bar: 'baz' }
@@ -89,7 +128,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'map_key' do
     it 'applies function to value under specified key' do
-      transformation = Transproc(:map_key, :user, Transproc(:symbolize_keys))
+      transformation = t(:map_key, :user, t(:symbolize_keys))
 
       input = { user: { 'name' => 'Jane' } }
       output = { user: { name: 'Jane' } }
@@ -101,7 +140,7 @@ describe 'Hash mapping with Transproc' do
 
   describe 'map_key!' do
     it 'applies function to value under specified key' do
-      transformation = Transproc(:map_key!, :user, Transproc(:symbolize_keys))
+      transformation = t(:map_key!, :user, t(:symbolize_keys))
 
       input = { user: { 'name' => 'Jane' } }
       output = { user: { name: 'Jane' } }
@@ -114,10 +153,10 @@ describe 'Hash mapping with Transproc' do
 
   describe 'nested transform' do
     it 'applies functions to nested hashes' do
-      symbolize_keys = Transproc(:symbolize_keys)
-      map_user_key = Transproc(:map_key, :user, symbolize_keys)
+      symbolize_keys = t(:symbolize_keys)
+      map_user_key = t(:map_key, :user, symbolize_keys)
 
-      transformation = symbolize_keys + map_user_key
+      transformation = symbolize_keys >> map_user_key
 
       input = { 'user' => { 'name' => 'Jane' } }
       output = { user: { name: 'Jane' } }
@@ -128,10 +167,10 @@ describe 'Hash mapping with Transproc' do
 
   describe 'combining transformations' do
     it 'applies functions to the hash' do
-      symbolize_keys = Transproc(:symbolize_keys)
-      map = Transproc(:map_hash, user_name: :name, user_email: :email)
+      symbolize_keys = t(:symbolize_keys)
+      map = t(:map_hash, user_name: :name, user_email: :email)
 
-      transformation = symbolize_keys + map
+      transformation = symbolize_keys >> map
 
       input = { 'user_name' => 'Jade', 'user_email' => 'jade@doe.org' }
       output = { name: 'Jade', email: 'jade@doe.org' }

data/spec/integration/recursion_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe 'Recursive transformations with Transproc' do
+  describe 'array_recursion' do
+    let(:original) do
+      [
+        'foo',
+        'bar',
+        nil,
+        [
+          'foo',
+          'bar',
+          nil,
+          [
+            'foo',
+            'bar',
+            nil
+          ]
+        ]
+      ]
+    end
+
+    let(:input) { original.dup }
+
+    let(:output) do
+      [
+        'foo',
+        'bar',
+        [
+          'foo',
+          'bar',
+          [
+            'foo',
+            'bar'
+          ]
+        ]
+      ]
+    end
+
+    context 'when function is non-destructive' do
+      let(:map) { t(:array_recursion, proc { |arr| arr.compact }) }
+
+      it 'applies funtions to all items recursively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(original)
+      end
+    end
+
+    context 'when function is destructive' do
+      let(:map) { t(:array_recursion, proc { |arr| arr.compact! }) }
+
+      it 'applies funtions to all items recursively and destructively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(output)
+      end
+    end
+  end
+
+  describe 'hash_recursion' do
+    let(:original) do
+      {
+        'foo' => 'bar',
+        'bar' => {
+          'foo' => 'bar',
+          'bar' => {
+            'foo' => 'bar'
+          }
+        },
+        'baz' => 'bar'
+      }
+    end
+
+    let(:input) { original.dup }
+
+    let(:output) do
+      {
+        foo: 'bar',
+        bar: {
+          foo: 'bar',
+          bar: {
+            foo: 'bar'
+          }
+        },
+        baz: 'bar'
+      }
+    end
+
+    context 'when function is non-destructive' do
+      let(:map) { t(:hash_recursion, t(:symbolize_keys)) }
+
+      it 'applies funtions to all values recursively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(original)
+      end
+    end
+
+    context 'when function is destructive' do
+      let(:map) { t(:hash_recursion, t(:symbolize_keys!)) }
+
+      it 'applies funtions to all values recursively and destructively' do
+        expect(map[input]).to eql(output)
+        expect(input).to eql(output)
+      end
+    end
+  end
+end

data/spec/integration/transproc_spec.rb

@@ -6,10 +6,10 @@ describe Transproc do
       input = '1'
       output = 1.0
 
-      to_i = Transproc(-> value { value.to_i })
-      to_f = Transproc(-> value { value.to_f })
+      to_i = t(-> value { value.to_i })
+      to_f = t(-> value { value.to_f })
 
-      result = to_i + to_f
+      result = to_i >> to_f
 
       expect(result[input]).to eql(output)
     end
@@ -19,7 +19,7 @@ describe Transproc do
     it 'allows registering functions by name' do
       Transproc.register(:to_boolean, -> value { value == 'true' })
 
-      result = Transproc(-> value { value.to_s }) + Transproc(:to_boolean)
+      result = t(-> value { value.to_s }) >> t(:to_boolean)
 
       expect(result[:true]).to be(true)
       expect(result[:false]).to be(false)
@@ -28,7 +28,7 @@ describe Transproc do
     it 'allows registering function by passing a block' do
       Transproc.register(:to_boolean) { |value| value == 'true' }
 
-      result = Transproc(-> value { value.to_s }) + Transproc(:to_boolean)
+      result = t(-> value { value.to_s }) >> t(:to_boolean)
 
       expect(result[:true]).to be(true)
       expect(result[:false]).to be(false)

data/spec/spec_helper.rb

@@ -9,3 +9,7 @@ begin
   require 'byebug'
 rescue LoadError
 end
+
+RSpec.configure do |config|
+  config.include(Transproc::Helper)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-14 00:00:00.000000000 Z
+date: 2015-04-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -75,11 +75,13 @@ files:
 - lib/transproc/composer.rb
 - lib/transproc/function.rb
 - lib/transproc/hash.rb
+- lib/transproc/recursion.rb
 - lib/transproc/version.rb
 - spec/integration/array_spec.rb
 - spec/integration/coercions_spec.rb
 - spec/integration/composer_spec.rb
 - spec/integration/hash_spec.rb
+- spec/integration/recursion_spec.rb
 - spec/integration/transproc_spec.rb
 - spec/spec_helper.rb
 - transproc.gemspec
@@ -112,5 +114,7 @@ test_files:
 - spec/integration/coercions_spec.rb
 - spec/integration/composer_spec.rb
 - spec/integration/hash_spec.rb
+- spec/integration/recursion_spec.rb
 - spec/integration/transproc_spec.rb
 - spec/spec_helper.rb
+has_rdoc: