transproc 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e3020e57756005b16449b171dc8532bd2c39887e
-  data.tar.gz: 06f27a81c36eec5993c51e64b58d440355ea1a12
+  metadata.gz: 03da4ea0974d24e43c94ab16d920532aa9703e9d
+  data.tar.gz: 5d0065ee097e3574e069062388f810ed0b81b108
 SHA512:
-  metadata.gz: 76b51f3ed36099dfa1410ac9aed768edab31275cc2057b50ee3e91b0795c36a8db2e030163c38f3be33fce5480b6523b3766f911951ed7026364310384b85412
-  data.tar.gz: 17d92360f7aaddc1f0a00fcf240f7402d9cf3419ed1c3b1a3e93e73b7a5781cfc8c8f84757b8b52529f9dadc7323e6d3302c840f017b60f80514b30ded93e05a
+  metadata.gz: dd79715c818c4161a4dbb574f8c2e359326a75739395f6ee1207dac1ffb40a138062090e2a1e94e6784ebc59dd46b8c1e036a149847ba5665ebf2635d7a53181
+  data.tar.gz: 915a231c2730edd26900c1ec7db8cacd5b0d7a1abc557f2e096334cf5e2092951b41b1c21239b173f257403ee42c03ffba2083dc59a31eaf5c2f9c3bddf0ee92

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+## v0.3.1 2015-08-06
+
+### Added
+
+* `:deep_merge` in `HashTransformations` (saturnflyer)
+* `Transproc::Function#to_proc` method (nepalez)
+* `to_boolean` coercion turns `nil` into `false` (c0)
+* Support symbolizing non-string values by `Coercions[:to_symbol]` and `HashTransformations[:symbolize_keys]` (nepalez)
+* Support for importing several functions at once `import :foo, :bar, from: Foo` (nepalez)
+
+[Compare v0.3.0...v0.3.1](https://github.com/solnic/transproc/compare/v0.3.0...v0.3.1)
+
 ## v0.3.0 2015-07-12
 
 This release deprecates a couple of APIs and changes the way functions can be
@@ -26,7 +38,7 @@ in 1.0.0.
 * `Transproc()` has been deprecated (solnic)
 * `Transproc::Helper` has been deprecated (solnic)
 
-[Compare v0.2.4...HEAD](https://github.com/solnic/transproc/compare/v0.2.4...HEAD)
+[Compare v0.2.4...v0.3.0](https://github.com/solnic/transproc/compare/v0.2.4...v0.3.0)
 
 ## v0.2.4 2015-06-20
 

data/README.md

@@ -14,8 +14,9 @@
 [![Test Coverage](https://codeclimate.com/github/solnic/transproc/badges/coverage.svg)][codeclimate]
 [![Inline docs](http://inch-ci.org/github/solnic/transproc.svg?branch=master)][inchpages]
 
-Functional transformations for Ruby. It's currently used as one of the data
-mapping backends in [Ruby Object Mapper](http://rom-rb.org).
+Transproc is a small library that allows you to compose methods into a functional pipeline using left-to-right function composition. It works like `|>` in Elixir or `>>` in F#.
+
+It's currently used as the data mapping backend in [Ruby Object Mapper](http://rom-rb.org).
 
 ## Installation
 
@@ -47,23 +48,27 @@ end
 
 # import necessary functions from external modules
 module Functions
-  # ...
-
   # all transformations available in the imported module
-  import Transproc::HashTransforations
+  import Transproc::HashTransformations
   import Transproc::ArrayTransformations
 
   # only specific transformation (renamed into the desired local name)
   import :camelize, from: Inflecto, as: :camel_case
 end
 
+def t(*args)
+  Functions[*args]
+end
+
 # use imported transformation
-transformation = Functions[:camel_case]
+transformation = t(:camel_case)
+
 transformation.call 'i_am_a_camel'
 # => "IAmACamel"
 
-transformation = Functions[:map_array, Functions[:symbolize_keys] >> Functions[:rename_keys, user_name: :user]]
-transformation >>= Functions[:wrap, :address, [:city, :street, :zipcode]]
+transformation = t(:map_array, t(:symbolize_keys) >> t(:rename_keys, user_name: :user))
+transformation >>= t(:wrap, :address, [:city, :street, :zipcode])
+
 transformation.call(
   [
     { 'user_name' => 'Jane',
@@ -75,7 +80,8 @@ transformation.call(
 # => [{:user=>"Jane", :address=>{:city=>"NYC", :street=>"Street 1", :zipcode=>"123"}}]
 
 # define your own composable transformation easily
-transformation = Functions[-> v { JSON.dump(v) }]
+transformation = t(-> v { JSON.dump(v) })
+
 transformation.call(name: 'Jane')
 # => "{\"name\":\"Jane\"}"
 
@@ -88,7 +94,8 @@ module Functions
   end
 end
 
-transformation = Functions[:load_json] >> Functions[:map_array, Functions[:symbolize_keys]]
+transformation = t(:load_json) >> t(:map_array, t(:symbolize_keys))
+
 transformation.call('[{"name":"Jane"}]')
 # => [{ :name => "Jane" }]
 ```

data/lib/transproc/coercions.rb

@@ -11,12 +11,27 @@ module Transproc
     extend Registry
 
     TRUE_VALUES = [true, 1, '1', 'on', 't', 'true', 'y', 'yes'].freeze
-    FALSE_VALUES = [false, 0, '0', 'off', 'f', 'false', 'n', 'no'].freeze
+    FALSE_VALUES = [false, 0, '0', 'off', 'f', 'false', 'n', 'no', nil].freeze
 
     BOOLEAN_MAP = Hash[
       TRUE_VALUES.product([true]) + FALSE_VALUES.product([false])
     ].freeze
 
+    # Does nothing and returns a value
+    #
+    # @example
+    #   fn = Coercions[:identity]
+    #   fn[:foo] # => :foo
+    #
+    # @param [Object] value
+    #
+    # @return [Object]
+    #
+    # @api public
+    def self.identity(value = nil)
+      value
+    end
+
     # Coerce value into a string
     #
     # @example
@@ -38,13 +53,13 @@ module Transproc
     #   Transproc(:to_symbol)['foo']
     #   # => :foo
     #
-    # @param [Object] value The input value
+    # @param [#to_s] value The input value
     #
     # @return [Symbol]
     #
     # @api public
     def self.to_symbol(value)
-      value.to_sym
+      value.to_s.to_sym
     end
 
     # Coerce value into a integer

data/lib/transproc/composer.rb

@@ -19,15 +19,6 @@ module Transproc
       super
     end
 
-    # @api private
-    def self.included(*)
-      Transproc::Deprecations.announce(
-        'Transproc::Helper',
-        'Define your own function registry using Transproc::Registry extension'
-      )
-      super
-    end
-
     # @see Transproc
     #
     # @api public

data/lib/transproc/conditional.rb

@@ -15,6 +15,23 @@ module Transproc
   module Conditional
     extend Registry
 
+    # Negates the result of transformation
+    #
+    # @example
+    #   fn = Conditional[:not, -> value { value.is_a? ::String }]
+    #   fn[:foo]  # => true
+    #   fn["foo"] # => false
+    #
+    # @param [Object] value
+    # @param [Proc] fn
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def self.not(value, fn)
+      !fn[value]
+    end
+
     # Apply the transformation function to subject if the predicate returns true, or return un-modified
     #
     # @example

data/lib/transproc/function.rb

@@ -89,5 +89,13 @@ module Transproc
     def to_ast
       [name, args]
     end
+
+    # Converts a transproc to a simple proc
+    #
+    # @return [Proc]
+    #
+    def to_proc
+      fn.to_proc
+    end
   end
 end

data/lib/transproc/hash.rb

@@ -429,6 +429,32 @@ module Transproc
       end
     end
 
+    # Merge a hash recursively
+    #
+    # @example
+    #
+    #   input = { 'foo' => 'bar', 'baz' => { 'one' => 1 } }
+    #   other = { 'foo' => 'buz', 'baz' => { :one => 'one', :two => 2 } }
+    #
+    #   t(:deep_merge)[input, other]
+    #   # => { 'foo' => "buz", :baz => { :one => 'one', 'one' => 1, :two => 2 } }
+    #
+    # @param [Hash]
+    # @param [Hash]
+    #
+    # @return [Hash]
+    #
+    # @api public
+    def self.deep_merge(hash, other)
+      Hash[hash].merge(other) do |key, original_value, new_value|
+        if original_value.respond_to?(:to_hash) && new_value.respond_to?(:to_hash)
+          deep_merge(Hash[original_value], Hash[new_value])
+        else
+          new_value
+        end
+      end
+    end
+
     # @deprecated Register methods globally
     (methods - Registry.instance_methods - Registry.methods)
       .each { |name| Transproc.register name, t(name) }

data/lib/transproc/registry.rb

@@ -54,46 +54,32 @@ module Transproc
     #
     # If the external module is a registry, looks for its imports too.
     #
-    # @example
-    #   module Foo
-    #     def self.foo(value)
-    #       value.upcase
-    #     end
-    #
-    #     def self.bar(value)
-    #       value.downcase
-    #     end
-    #  end
-    #
-    #  module Qux
-    #    def self.qux(value)
-    #      value.reverse
-    #    end
-    #  end
-    #
-    #  module Bar
-    #     extend Transproc::Registry
-    #
-    #     import :foo, from: Foo, as: :baz
-    #     import :bar, from: Foo
-    #     import Qux
-    #  end
-    #
-    #  Bar[:baz]['Qux'] # => 'QUX'
-    #  Bar[:bar]['Qux'] # => 'qux'
-    #  Bar[:qux]['Qux'] # => 'xuQ'
-    #
-    # @param [Module, #to_sym] name
-    # @option [Module] :from The module to take the method from
-    # @option [#to_sym] :as
-    #   The name of imported transproc inside the current module
+    # @overload import(source)
+    #   Loads all methods from the source object
+    #
+    #   @param [Object] source
+    #
+    # @overload import(*names, **options)
+    #   Loads selected methods from the source object
+    #
+    #   @param [Array<Symbol>] names
+    #   @param [Hash] options
+    #   @options options [Object] :from The source object
+    #
+    # @overload import(name, **options)
+    #   Loads selected methods from the source object
+    #
+    #   @param [Symbol] name
+    #   @param [Hash] options
+    #   @options options [Object] :from The source object
+    #   @options options [Object] :as The new name for the transformation
     #
     # @return [itself] self
     #
     # @alias :import
     #
-    def import(source, options = nil)
-      @store = store.import(source, options)
+    def import(*args)
+      @store = store.import(*args)
       self
     end
     alias_method :uses, :import

data/lib/transproc/rspec.rb

@@ -5,21 +5,23 @@
 # ==============================================================================
 
 shared_context :call_transproc do
-  let!(:initial)  { input.dup rescue input      }
-  let!(:function) { described_class[*arguments] }
-  let!(:result)   { function[input]             }
+  let!(:__initial__) { input.dup rescue input      }
+  let!(:__fn__)      { described_class[*arguments] }
+  subject { __fn__[input] }
 end
 
 shared_examples :transforming_data do
+  include_context :call_transproc
+
   it '[returns the expected output]' do
-    expect(result).to eql(output), <<-REPORT.gsub(/.+\|/, "")
+    expect(subject).to eql(output), <<-REPORT.gsub(/.+\|/, "")
       |
       |fn = #{described_class}#{Array[*arguments]}
       |
       |fn[#{input}]
       |
       |  expected: #{output}
-      |       got: #{result}
+      |       got: #{subject}
     REPORT
   end
 end
@@ -30,13 +32,14 @@ shared_examples :transforming_immutable_data do
   it_behaves_like :transforming_data
 
   it '[keeps input unchanged]' do
-    expect(input).to eql(initial), <<-REPORT.gsub(/.+\|/, "")
-      |
-      |fn = #{described_class}#{Array[*arguments]}
-      |
-      |expected: not to change #{initial}
-      |     got: changed it to #{input}
-    REPORT
+    expect { subject }
+      .not_to change { input }, <<-REPORT.gsub(/.+\|/, "")
+        |
+        |fn = #{described_class}#{Array[*arguments]}
+        |
+        |expected: not to change #{__initial__}
+        |     got: changed it to #{input}
+      REPORT
   end
 end
 
@@ -46,14 +49,16 @@ shared_examples :mutating_input_data do
   it_behaves_like :transforming_data
 
   it '[changes input]' do
-    expect(input).to eql(output), <<-REPORT.gsub(/.+\|/, "")
-      |
-      |fn = #{described_class}#{Array[*arguments]}
-      |
-      |fn[#{input}]
-      |
-      |expected: to change input to #{output}
-      |     got: #{input}
-    REPORT
+    expect { subject }
+      .to change { input }
+      .to(output), <<-REPORT.gsub(/.+\|/, "")
+        |
+        |fn = #{described_class}#{Array[*arguments]}
+        |
+        |fn[#{input}]
+        |
+        |expected: to change input to #{output}
+        |     got: #{input}
+      REPORT
   end
 end

data/lib/transproc/store.rb

@@ -38,17 +38,18 @@ module Transproc
 
     # Imports proc(s) to the collection from another module
     #
-    # @overload add(source)
-    #   @param  (see #import_methods)
-    #   @return (see #import_methods)
-    #
-    # @overload add(source, options)
-    #   @param  (see #import_method)
-    #   @return (see #import_method)
+    # @private
     #
-    def import(source, options = nil)
-      return import_methods(source) if source.instance_of?(Module)
-      import_method(source, options)
+    def import(*args)
+      first = args.first
+      return import_all(first) if first.instance_of?(Module)
+
+      opts   = args.pop
+      source = opts.fetch(:from)
+      rename = opts.fetch(:as) { first.to_sym }
+
+      return import_methods(source, args) if args.count > 1
+      import_method(source, first, rename)
     end
 
     protected
@@ -57,22 +58,31 @@ module Transproc
     # updated with either the module's singleton method,
     # or the proc having been imported from another module.
     #
-    # @param [Symbol] source The name of the method, or imported proc
-    # @param [Hash] options
-    # @option options [Module] :from
-    #   The module whose method or imported proc should be added
-    # @option options [Symbol] :as
-    #   The key for the proc in the current collection
+    # @param [Module] source
+    # @param [Symbol] name
+    # @param [Symbol] new_name
     #
     # @return [Transproc::Store]
     #
-    def import_method(source, options)
-      src  = options.fetch(:from)
-      name = source.to_sym
-      key  = options.fetch(:as) { name }.to_sym
-      fn   = src.is_a?(Registry) ? src.fetch(name) : src.method(name)
+    def import_method(source, name, new_name = name)
+      from = name.to_sym
+      to   = new_name.to_sym
+
+      fn = source.is_a?(Registry) ? source.fetch(from) : source.method(from)
+      self.class.new(methods.merge(to => fn))
+    end
 
-      self.class.new(methods.merge(key => fn))
+    # Creates new immutable collection from the current one,
+    # updated with either the module's singleton methods,
+    # or the procs having been imported from another module.
+    #
+    # @param [Module] source
+    # @param [Array<Symbol>] names
+    #
+    # @return [Transproc::Store]
+    #
+    def import_methods(source, names)
+      names.inject(self) { |a, e| a.import_method(source, e) }
     end
 
     # Creates new immutable collection from the current one,
@@ -83,12 +93,12 @@ module Transproc
     #
     # @return [Transproc::Store]
     #
-    def import_methods(source)
-      list =  source.public_methods - Registry.instance_methods - Module.methods
-      list -= [:initialize] # for compatibility with Rubinius
-      list += source.store.methods.keys if source.is_a? Registry
+    def import_all(source)
+      names = source.public_methods - Registry.instance_methods - Module.methods
+      names -= [:initialize] # for compatibility with Rubinius
+      names += source.store.methods.keys if source.is_a? Registry
 
-      list.inject(self) { |a, e| a.import_method(e, from: source) }
+      import_methods(source, names)
     end
   end # class Store
 end # module Transproc

data/lib/transproc/version.rb

@@ -1,3 +1,3 @@
 module Transproc
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.3.1'.freeze
 end

data/spec/unit/coercions_spec.rb

@@ -1,6 +1,18 @@
 require 'spec_helper'
 
 describe Transproc::Coercions do
+  describe '.identity' do
+    let(:fn) { described_class.t(:identity) }
+
+    it 'returns the original value' do
+      expect(fn[:foo]).to eql :foo
+    end
+
+    it 'returns nil by default' do
+      expect(fn[]).to eql nil
+    end
+  end
+
   describe '.to_string' do
     it 'turns integer into a string' do
       expect(described_class.t(:to_string)[1]).to eql('1')
@@ -11,6 +23,10 @@ describe Transproc::Coercions do
     it 'turns string into a symbol' do
       expect(described_class.t(:to_symbol)['test']).to eql(:test)
     end
+
+    it 'turns non-string into a symbol' do
+      expect(described_class.t(:to_symbol)[1]).to eql(:'1')
+    end
   end
 
   describe '.to_integer' do

data/spec/unit/conditional_spec.rb

@@ -1,6 +1,29 @@
 require 'spec_helper'
 
 describe Transproc::Conditional do
+  describe '.not' do
+    let(:fn) { described_class.t(:not, -> value { value.is_a? String }) }
+    subject  { fn[input] }
+
+    context 'when predicate returns truthy value' do
+      let(:input)  { 'foo' }
+      let(:output) { false }
+
+      it 'applies the first transformation' do
+        expect(subject).to eql output
+      end
+    end
+
+    context 'when predicate returns falsey value' do
+      let(:input)  { :foo }
+      let(:output) { true }
+
+      it 'applies the first transformation' do
+        expect(subject).to eql output
+      end
+    end
+  end
+
   describe '.guard' do
     let(:fn) { described_class.t(:guard, condition, operation) }
     let(:condition) { ->(value) { value.is_a?(::String) } }

data/spec/unit/function_spec.rb

@@ -117,4 +117,45 @@ describe Transproc::Function do
       expect(left == right).to be(false)
     end
   end
+
+  describe '#to_proc' do
+    shared_examples :providing_a_proc do
+      let(:fn) { described_class.new(source) }
+      subject  { fn.to_proc }
+
+      it 'returns a proc' do
+        expect(subject).to be_instance_of Proc
+      end
+
+      it 'works fine' do
+        expect(subject.call :foo).to eql('foo')
+      end
+    end
+
+    context 'from a method' do
+      let(:source) do
+        mod = Module.new do
+          def self.get(x)
+            x.to_s
+          end
+        end
+        mod.method(:get)
+      end
+      it_behaves_like :providing_a_proc
+    end
+
+    context 'from a proc' do
+      let(:source) { -> value { value.to_s } }
+      it_behaves_like :providing_a_proc
+    end
+
+    context 'from a transproc' do
+      let(:source) { Transproc::Function.new -> value { value.to_s } }
+      it_behaves_like :providing_a_proc
+
+      it 'can be applied to collection' do
+        expect([:foo, :bar].map(&source)).to eql(%w(foo bar))
+      end
+    end
+  end
 end

data/spec/unit/hash_transformations_spec.rb

@@ -30,11 +30,11 @@ describe Transproc::HashTransformations do
     it 'returns a new hash with symbolized keys' do
       symbolize_keys = described_class.t(:symbolize_keys)
 
-      input = { 'foo' => 'bar' }
-      output = { foo: 'bar' }
+      input = { 1 => 'bar' }
+      output = { :'1' => 'bar' }
 
       expect(symbolize_keys[input]).to eql(output)
-      expect(input).to eql('foo' => 'bar')
+      expect { symbolize_keys[input] }.not_to change { input }
     end
   end
 
@@ -509,4 +509,44 @@ describe Transproc::HashTransformations do
       expect(result[:hash]).to eql(one: 1)
     end
   end
+
+  describe '.deep_merge' do
+    let(:hash){
+      {
+        name: 'Jane',
+        email: 'jane@doe.org',
+        favorites:
+          {
+            food: 'stroopwafel'
+          }
+      }
+    }
+
+    let(:update){
+      {
+        email: 'jane@example.org',
+        favorites:
+          {
+            color: 'orange'
+          }
+      }
+    }
+
+    it 'recursively merges hash values' do
+      deep_merge = described_class.t(:deep_merge)
+      output = { name: 'Jane', email: 'jane@example.org', favorites: { food: 'stroopwafel', color: 'orange' } }
+
+      expect(deep_merge[hash, update]).to eql(output)
+    end
+
+    it 'does not alter the provided arguments' do
+      original_hash = hash.dup
+      original_update = update.dup
+
+      described_class.t(:deep_merge)[hash, update]
+
+      expect(hash).to eql(original_hash)
+      expect(update).to eql(original_update)
+    end
+  end
 end

data/spec/unit/registry_spec.rb

@@ -77,6 +77,17 @@ describe Transproc::Registry do
       end
     end
 
+    context 'a list of methods' do
+      before { bar.import :prefix, from: foo }
+      before { bar.import :prefix, from: foo, as: :affix }
+      before { baz.import :prefix, :affix, from: bar }
+
+      it 'registers a transproc' do
+        expect(baz[:prefix, 'bar']['baz']).to eql 'bar_baz'
+        expect(baz[:affix, 'bar']['baz']).to eql 'bar_baz'
+      end
+    end
+
     context 'a renamed method' do
       before { bar.import :prefix, from: foo, as: :affix }
 

data/spec/unit/store_spec.rb

@@ -38,7 +38,7 @@ describe Transproc::Store do
     end
   end # describe #fetch
 
-  describe '#import' do
+  describe '#import', :focus do
     before do
       module Bar
         def self.bar
@@ -91,6 +91,20 @@ describe Transproc::Store do
       end
     end
 
+    context 'named methods' do
+      subject { store.import 'qux', 'bar', from: Qux }
+
+      it_behaves_like :importing_method do
+        let(:key)   { :qux }
+        let(:value) { :qux }
+      end
+
+      it_behaves_like :importing_method do
+        let(:key)   { :bar }
+        let(:value) { :bar }
+      end
+    end
+
     context 'renamed method' do
       subject { store.import 'qux', from: Qux, as: 'quxx' }
 

data/spec/unit/transproc_spec.rb

@@ -17,11 +17,11 @@ describe Transproc do
 
   describe '.register' do
     it 'allows registering functions by name' do
-      Transproc.register(:identity, -> value { value })
+      Transproc.register(:id, -> value { value })
 
       value = 'hello world'
 
-      result = t(:identity)[value]
+      result = t(:id)[value]
 
       expect(result).to be(value)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-12 00:00:00.000000000 Z
+date: 2015-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler