transproc 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8df075878909a89bb9304ac442044a20d768860b
-  data.tar.gz: 2ebde290094e7cf302891f536c043af3c933f6b3
+  metadata.gz: a5ce7c814504a4dbdb337c06e34e0d8ba76240c2
+  data.tar.gz: 7634b2a430e84411fdf9b3454f8a9e530167efef
 SHA512:
-  metadata.gz: 5baa7f8034bb8e727c1a0f8870a4f5e9f5ec9c9d4f04ad39400572473fa543aca6ab6540ba6658a75570acf068010f0637102ac973772e349cc8a59949c602d8
-  data.tar.gz: 86a696d76233333a933bec5fd4ac83052cc4ce04bab8ae9bb9c11204caae818fa9020392846ff7a948b3c30fdaaa28257cad8448cf46a0d90a3a166b26b4962c
+  metadata.gz: 03cdc29204c0aeec12217dfc88a838d052fa3dbed8be7b66c1c8326ccd09bb9a0a2445dd4c535916da0e0fa2546340882867adcc897586e1e0f2b42244cf1c74
+  data.tar.gz: a0c2124b3455b1d240a27420214a0ba5b31c8114a2002032fba26e02938fdb1ed99183a2b4a01bfdc250e16fd58a06b92612a78f5b7c8e017e95ab20bf6efabe

data/.rspec

@@ -1,2 +1,3 @@
 --color
 --require spec_helper
+--warnings

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## v0.2.3 2015-06-02
+
+### Added
+
+* `:split` splits a hash to array by a list of values from a specified key of the hash (nepalez)
+* `:ungroup` is an inverse array transormation with respect to the `:group` (nepalez)
+* `:insert_key` (and `:insert_key!`) is the partial inversion of `:extract_key`.
+  The method converts array of values into array of tuples with given key (nepalez)
+* `:add_keys` (and `:add_keys!`) adds missing keys to all tuples in array (nepalez)
+
+### Fixed
+
+* Warning about circular requires is gone now (splattael)
+
+[Compare v0.2.2...v0.2.3](https://github.com/solnic/transproc/compare/v0.2.2...v0.2.3)
+
 ## v0.2.2 2015-05-22
 
 ### Added

data/lib/transproc.rb

@@ -1,5 +1,6 @@
 require 'transproc/version'
 require 'transproc/function'
+require 'transproc/functions'
 require 'transproc/composer'
 require 'transproc/error'
 
@@ -42,29 +43,11 @@ module Transproc
   def functions
     @_functions ||= {}
   end
-
-  # Function container extension
-  #
-  # @example
-  #   module MyTransformations
-  #     extend Transproc::Functions
-  #
-  #     def boom!(value)
-  #       "#{value} BOOM!"
-  #     end
-  #   end
-  #
-  #   Transproc(:boom!)['w00t!'] # => "w00t! BOOM!"
-  #
-  # @api public
-  module Functions
-    def method_added(meth)
-      module_function meth
-      Transproc.register(meth, method(meth))
-    end
-  end
 end
 
+require 'transproc/array'
+require 'transproc/hash'
+
 # Access registered functions
 #
 # @example

data/lib/transproc/array.rb

@@ -1,5 +1,3 @@
-require 'transproc/hash'
-
 module Transproc
   # Transformation functions for Array objects
   #
@@ -99,6 +97,30 @@ module Transproc
       end
     end
 
+    # Ungroup array values using provided root key and value keys
+    #
+    # @example
+    #   fn = Transproc(:group, :tags, [:tag_name])
+    #
+    #   fn.call [
+    #     { task: 'Group it', tags: [{ tag: 'task' }, { tag: 'important' }]
+    #   ]
+    #   # => [
+    #     { task: 'Group it', tag: 'task' },
+    #     { task: 'Group it', tag: 'important' }
+    #   ]
+    #
+    # @param [Array] array The input array
+    # @param [Object] key The nesting root key
+    # @param [Object] keys The nesting value keys
+    #
+    # @return [Array]
+    #
+    # @api public
+    def ungroup(array, key, keys)
+      array.flat_map { |item| HashTransformations.split(item, key, keys) }
+    end
+
     # Combines two arrays by merging child items from right array using join keys
     #
     # @example
@@ -175,5 +197,55 @@ module Transproc
     def extract_key!(array, key)
       map_array!(array, -> v { v[key] })
     end
+
+    # Wraps every value of the array to tuple with given key
+    #
+    # The transformation partially inverses the `extract_key`.
+    #
+    # @example
+    #   fn = t(:insert_key, 'name')
+    #   fn.call ['Alice', 'Bob', nil]
+    #   # => [{ 'name' => 'Alice' }, { 'name' => 'Bob' }, { 'name' => nil }]
+    #
+    # @param [Array<Hash>] array The input array of hashes
+    # @param [Object] key The key to extract values by
+    #
+    # @return [Array]
+    #
+    # @api public
+    def insert_key(array, key)
+      insert_key!(Array[*array], key)
+    end
+
+    # Same as `insert_key` but mutates the array
+    #
+    # @see ArrayTransformations.insert_key
+    #
+    # @api public
+    def insert_key!(array, key)
+      map_array!(array, -> v { { key => v } })
+    end
+
+    # Adds missing keys with nil value to all tuples in array
+    #
+    # @param [Array] keys
+    #
+    # @return [Array]
+    #
+    # @api public
+    #
+    def add_keys(array, keys)
+      add_keys!(Array[*array], keys)
+    end
+
+    # Same as `add_keys` but mutates the array
+    #
+    # @see ArrayTransformations.add_keys
+    #
+    # @api public
+    def add_keys!(array, keys)
+      base = keys.inject({}) { |a, e| a.merge(e => nil) }
+      map_array!(array, -> v { base.merge(v) })
+    end
   end
 end

data/lib/transproc/functions.rb

@@ -0,0 +1,22 @@
+module Transproc
+  # Function container extension
+  #
+  # @example
+  #   module MyTransformations
+  #     extend Transproc::Functions
+  #
+  #     def boom!(value)
+  #       "#{value} BOOM!"
+  #     end
+  #   end
+  #
+  #   Transproc(:boom!)['w00t!'] # => "w00t! BOOM!"
+  #
+  # @api public
+  module Functions
+    def method_added(meth)
+      module_function meth
+      Transproc.register(meth, method(meth))
+    end
+  end
+end

data/lib/transproc/hash.rb

@@ -1,4 +1,3 @@
-require 'transproc/array'
 require 'transproc/coercions'
 
 module Transproc
@@ -146,15 +145,6 @@ module Transproc
       hash
     end
 
-    # Same as `:reject_keys` but mutates the hash
-    #
-    # @see HashTransformations.reject_keys
-    #
-    # @api public
-    def reject_keys!(hash, keys)
-      hash.reject { |k, _| keys.include?(k) }
-    end
-
     # Rejects specified keys from a hash
     #
     # @example
@@ -171,13 +161,13 @@ module Transproc
       reject_keys!(Hash[hash], keys)
     end
 
-    # Same as `:accept_keys` but mutates the hash
+    # Same as `:reject_keys` but mutates the hash
     #
     # @see HashTransformations.reject_keys
     #
     # @api public
-    def accept_keys!(hash, keys)
-      reject_keys!(hash, hash.keys - keys)
+    def reject_keys!(hash, keys)
+      hash.reject { |k, _| keys.include?(k) }
     end
 
     # Accepts specified keys from a hash
@@ -196,6 +186,15 @@ module Transproc
       accept_keys!(Hash[hash], keys)
     end
 
+    # Same as `:accept_keys` but mutates the hash
+    #
+    # @see HashTransformations.accept
+    #
+    # @api public
+    def accept_keys!(hash, keys)
+      reject_keys!(hash, hash.keys - keys)
+    end
+
     # Map a key in a hash with the provided transformation function
     #
     # @example
@@ -213,7 +212,7 @@ module Transproc
 
     # Same as `:map_value` but mutates the hash
     #
-    # @see HashTransformations.map_value!
+    # @see HashTransformations.map_value
     #
     # @api public
     def map_value!(hash, key, fn)
@@ -272,9 +271,10 @@ module Transproc
     # @see HashTransformations.unwrap
     #
     # @api public
-    def unwrap!(hash, root, keys = nil)
+    def unwrap!(hash, root, selected = nil)
       if nested_hash = hash[root]
-        keys ||= nested_hash.keys
+        keys = nested_hash.keys
+        keys &= selected if selected
         hash.update(Hash[keys.zip(keys.map { |key| nested_hash.delete(key) })])
         hash.delete(root) if nested_hash.empty?
       end
@@ -284,8 +284,6 @@ module Transproc
 
     # Folds array of tuples to array of values from a specified key
     #
-    # The second argument defines the key to fold tuples by
-    #
     # @example
     #   source = {
     #     name: "Jane",
@@ -296,7 +294,9 @@ module Transproc
     #   Transproc(:fold, :tasks, :priority)[source]
     #   # => { name: "Jane", tasks: [1, nil] }
     #
-    # @param [Hash]
+    # @param [Hash] hash
+    # @param [Object] key The key to fold values to
+    # @param [Object] tuple_key The key to take folded values from
     #
     # @return [Hash]
     #
@@ -313,5 +313,46 @@ module Transproc
     def fold!(hash, key, tuple_key)
       hash.merge!(key => ArrayTransformations.extract_key(hash[key], tuple_key))
     end
+
+    # Splits hash to array by all values from a specified key
+    #
+    # The operation adds missing keys extracted from the array to regularize the output.
+    #
+    # @example
+    #   input = {
+    #     name: 'Joe',
+    #     tasks: [
+    #       { title: 'sleep well', priority: 1 },
+    #       { title: 'be nice',    priority: 2 },
+    #       {                      priority: 2 },
+    #       { title: 'be cool'                 }
+    #     ]
+    #   }
+    #   Transproc(:split, :tasks, [:priority])
+    #   => [
+    #       { 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' }]                 }
+    #     ]
+    #
+    # @param [Hash] hash
+    # @param [Object] key The key to split a hash by
+    # @param [Array] subkeys The list of subkeys to be extracted from key
+    #
+    # @return [Array<Hash>]
+    #
+    # @api public
+    def split(hash, key, keys)
+      list = Array(hash[key])
+      return [hash.reject { |k, _| k == key }] if list.empty?
+
+      existing  = list.flat_map(&:keys).uniq
+      grouped   = existing - keys
+      ungrouped = existing & keys
+
+      list = ArrayTransformations.group(list, key, grouped) if grouped.any?
+      list = list.map { |item| item.merge(reject_keys(hash, [key])) }
+      ArrayTransformations.add_keys(list, ungrouped)
+    end
   end
 end

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.2.2'.freeze
+  VERSION = '0.2.3'.freeze
 end

data/spec/unit/array_transformations_spec.rb

@@ -37,6 +37,80 @@ describe Transproc::ArrayTransformations do
     end
   end
 
+  describe '.insert_key' do
+    it 'wraps values to tuples with given key' do
+      insert_key = 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(original)
+    end
+  end
+
+  describe '.insert_key!' do
+    it 'wraps values to tuples with given key' do
+      insert_key = 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
+
+  describe '.add_keys' do
+    it 'returns a new array with missed keys added to tuples' do
+      add_keys = 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(original)
+    end
+  end
+
+  describe '.add_keys!' do
+    it 'adds missed keys to tuples' do
+      add_keys = 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
+
   describe '.map_array' do
     it 'applies funtions to all values' do
       map = t(:map_array, t(:symbolize_keys))
@@ -114,6 +188,31 @@ describe Transproc::ArrayTransformations do
     end
   end
 
+  describe '.ungroup' do
+    subject(:ungroup) { t(:ungroup, :tasks, [:title]) }
+
+    it 'returns a new array with ungrouped hashes' do
+      input = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
+      output = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+
+    it 'returns an input with empty array removed' do
+      input = [{ name: 'Jane', tasks: [] }]
+      output = [{ name: 'Jane' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+
+    it 'returns an input when a key is absent' do
+      input = [{ name: 'Jane' }]
+      output = [{ name: 'Jane' }]
+
+      expect(ungroup[input]).to eql(output)
+    end
+  end
+
   describe '.combine' do
     let(:input) do
       [

data/spec/unit/hash_transformations_spec.rb

@@ -206,6 +206,17 @@ describe Transproc::HashTransformations do
 
       expect(input).to eql(output)
     end
+
+    it 'ignores unknown keys' do
+      unwrap = t(:unwrap!, 'wrapped', %w(one two three))
+
+      input = { 'wrapped' => { 'one' => nil, 'two' => false } }
+      output = { 'one' => nil, 'two' => false }
+
+      unwrap[input]
+
+      expect(input).to eql(output)
+    end
   end
 
   describe '.unwrap' do
@@ -354,4 +365,88 @@ describe Transproc::HashTransformations do
       expect(input).to eql output
     end
   end
+
+  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 = 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 = 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 = t(:split, :tasks, [])
+      expect(split[input]).to eql output
+
+      split = t(:split, :tasks, [:absent])
+      expect(split[input]).to eql output
+    end
+
+    it 'returns an array of initial tuple when attribute is absent' do
+      split = t(:split, :absent, [:priority, :title])
+      expect(split[input]).to eql [input]
+    end
+
+    it 'ignores empty array' do
+      input = { name: 'Joe', tasks: [] }
+
+      split = t(:split, :tasks, [:title])
+
+      expect(split[input]).to eql [{ name: 'Joe' }]
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-22 00:00:00.000000000 Z
+date: 2015-06-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,7 @@ files:
 - lib/transproc/conditional.rb
 - lib/transproc/error.rb
 - lib/transproc/function.rb
+- lib/transproc/functions.rb
 - lib/transproc/hash.rb
 - lib/transproc/recursion.rb
 - lib/transproc/version.rb