transproc 1.0.0 → 1.1.1

data/spec/unit/array_transformations_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::ArrayTransformations do
   let(:hashes) { Transproc::HashTransformations }
@@ -230,55 +230,4 @@ describe Transproc::ArrayTransformations do
       expect(ungroup[input]).to eql(output)
     end
   end
-
-  describe '.combine' do
-    it 'merges hashes from arrays using provided join keys' do
-      input = [
-        # parent users
-        [
-          { name: 'Jane', email: 'jane@doe.org' },
-          { name: 'Joe', email: 'joe@doe.org' }
-        ],
-        [
-          [
-            # user tasks
-            [
-              { user: 'Jane', title: 'One' },
-              { user: 'Jane', title: 'Two' },
-              { user: 'Joe', title: 'Three' }
-            ],
-            [
-              # task tags
-              [
-                { task: 'One', tag: 'red' },
-                { task: 'Three', tag: 'blue' }
-              ]
-            ]
-          ]
-        ]
-      ]
-
-      output = [
-        { name: 'Jane', email: 'jane@doe.org', tasks: [
-          { user: 'Jane', title: 'One', tags: [{ task: 'One', tag: 'red' }] },
-          { user: 'Jane', title: 'Two', tags: [] }]
-        },
-        {
-          name: 'Joe', email: 'joe@doe.org', tasks: [
-            {
-              user: 'Joe', title: 'Three', tags: [
-                { task: 'Three', tag: 'blue' }
-              ]
-            }
-          ]
-        }
-      ]
-
-      combine = described_class.t(:combine, [
-        [:tasks, { name: :user }, [[:tags, title: :task]]]
-      ])
-
-      expect(combine[input]).to eql(output)
-    end
-  end
 end

data/spec/unit/class_transformations_spec.rb

@@ -1,9 +1,11 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require 'dry/equalizer'
 
 describe Transproc::ClassTransformations do
   describe '.constructor_inject' do
     let(:klass) do
-      Struct.new(:name, :age) { include Equalizer.new(:name, :age) }
+      Struct.new(:name, :age) { include Dry::Equalizer.new(:name, :age) }
     end
 
     it 'returns a new object initialized with the given arguments' do
@@ -21,12 +23,13 @@ describe Transproc::ClassTransformations do
   describe '.set_ivars' do
     let(:klass) do
       Class.new do
-        include Anima.new(:name, :age)
+        include Dry::Equalizer.new(:name, :age)
 
-        attr_reader :test
+        attr_reader :name, :age, :test
 
-        def initialize(*args)
-          super
+        def initialize(name:, age:)
+          @name = name
+          @age = age
           @test = true
         end
       end
@@ -36,7 +39,7 @@ describe Transproc::ClassTransformations do
       set_ivars = described_class.t(:set_ivars, klass)
 
       input = { name: 'Jane', age: 25 }
-      output = klass.new(input)
+      output = klass.new(**input)
       result = set_ivars[input]
 
       expect(result).to eql(output)

data/spec/unit/coercions_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Coercions do
   describe '.identity' do

data/spec/unit/composer_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Composer do
   before do

data/spec/unit/conditional_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Conditional do
   describe '.not' do

data/spec/unit/function_not_found_error_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 describe Transproc::FunctionNotFoundError do
   it 'complains that the function not registered' do

data/spec/unit/function_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Function do
   let(:container) do
@@ -98,6 +98,21 @@ describe Transproc::Function do
       expect(fn[:ok]).to eql('ok')
       expect(fn.to_ast).to eql([:to_string, []])
     end
+
+    it 'plays well with functions as arguments' do
+      container.register(:map_array, Transproc::ArrayTransformations.t(:map_array))
+      container.register(:to_symbol, Transproc::Coercions.t(:to_symbol))
+      fn = container.t(:map_array, container.t(:to_symbol))
+
+      expect(fn.call(%w(a b c))).to eql([:a, :b, :c])
+      expect(fn.to_ast).to eql(
+        [
+          :map_array, [
+            [:to_symbol, []]
+          ]
+        ]
+      )
+    end
   end
 
   describe '#==' do

data/spec/unit/hash_transformations_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::HashTransformations do
   describe '.map_keys' do
@@ -50,6 +50,17 @@ describe Transproc::HashTransformations do
     end
   end
 
+  describe '.deep_stringify_keys' do
+    it 'returns a new hash with symbolized keys' do
+      stringify_keys = described_class.t(:deep_stringify_keys)
+
+      input = { foo: 'bar', baz: [{ one: 1 }, 'two'] }
+      output = { 'foo' => 'bar', 'baz' => [{ 'one' => 1 }, 'two'] }
+
+      expect(stringify_keys[input]).to eql(output)
+    end
+  end
+
   it { expect(described_class).not_to be_contain(:stringify_keys!) }
 
   describe '.map_values' do

data/spec/unit/proc_transformations_spec.rb

@@ -1,4 +1,6 @@
-require 'spec_helper'
+# frozen_string_literal: true
+
+require 'ostruct'
 
 describe Transproc::ProcTransformations do
   describe '.bind' do

data/spec/unit/recursion_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Recursion do
   let(:hashes) { Transproc::HashTransformations }

data/spec/unit/registry_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+# frozen_string_literal: true
 
 describe Transproc::Registry do
   before { module Transproc::Test; end         }
@@ -100,6 +100,14 @@ describe Transproc::Registry do
       expect(foo[:prefix_one]).to eq function
     end
 
+    it 'allows to overwrite function arguments' do
+      foo.register(:map_array, Transproc::ArrayTransformations.t(:map_array))
+
+      fn = foo[:map_array, ->(value) { value.to_sym }]
+
+      expect(fn.call(%w(a b c))).to eq([:a, :b, :c])
+    end
+
     it 'registers and fetches composite' do
       composite = foo[:prefix, '1'] + foo[:prefix, '2']
       foo.register(:double_prefix, composite)

data/spec/unit/store_spec.rb

@@ -1,4 +1,4 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 describe Transproc::Store do
   let(:store) { described_class.new methods      }
@@ -186,6 +186,7 @@ describe Transproc::Store do
       end
 
       it 'skips Transproc::Registry singleton methods' do
+        pending "this fails for some reason" if RUBY_ENGINE == "jruby"
         expect(subject.methods.keys).to contain_exactly(:foo, :bar, :baz, :qux)
       end
     end

data/spec/unit/transformer/class_interface_spec.rb

@@ -0,0 +1,364 @@
+# frozen_string_literal: true
+
+require 'ostruct'
+require 'dry/equalizer'
+
+describe Transproc::Transformer do
+  let(:container) { Module.new { extend Transproc::Registry } }
+  let(:klass) { Transproc::Transformer[container] }
+  let(:transformer) { klass.new }
+
+  describe '.import' do
+    it 'allows importing functions into an auto-configured registry' do
+      klass = Class.new(Transproc::Transformer) do
+        import Transproc::ArrayTransformations
+        import Transproc::Coercions
+
+        define! do
+          map_array(&:to_symbol)
+        end
+      end
+
+      transformer = klass.new
+
+      expect(transformer.(['foo', 'bar'])).to eql([:foo, :bar])
+    end
+  end
+
+  describe '.new' do
+    it 'supports arguments' do
+      klass = Class.new(Transproc::Transformer) do
+        import Transproc::ArrayTransformations
+        import Transproc::Coercions
+
+        define! do
+          map_array(&:to_symbol)
+        end
+
+        def initialize(good)
+          @good = good
+        end
+
+        def good?
+          @good
+        end
+      end
+
+      transformer = klass.new(true)
+
+      expect(transformer).to be_good
+    end
+  end
+
+  describe '.container' do
+    it 'returns the configured container' do
+      expect(klass.container).to be(container)
+    end
+
+    context 'with setter argument' do
+      let(:container) { double(:custom_container) }
+
+      it 'sets and returns the container' do
+        klass.container(container)
+
+        expect(klass.container).to be(container)
+      end
+    end
+  end
+
+  describe 'inheritance' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        def self.arbitrary(value, fn)
+          fn[value]
+        end
+      end
+    end
+
+    let(:superclass) do
+      Class.new(Transproc::Transformer[container]) do
+        define! do
+          arbitrary ->(v) { v + 1 }
+        end
+      end
+    end
+
+    let(:subclass) do
+      Class.new(superclass) do
+        define! do
+          arbitrary ->(v) { v * 2 }
+        end
+      end
+    end
+
+    it 'inherits container from superclass' do
+      expect(subclass.container).to be(superclass.container)
+    end
+
+    it 'inherits transproc from superclass' do
+      expect(superclass.new.call(2)).to be(3)
+      expect(subclass.new.call(2)).to be(6)
+    end
+  end
+
+  describe '.[]' do
+    subject(:subclass) { klass[another_container] }
+
+    let(:another_container) { double('Transproc') }
+
+    it 'sets a container' do
+      expect(subclass.container).to be(another_container)
+    end
+
+    it 'returns a class' do
+      expect(subclass).to be_a(Class)
+    end
+
+    it 'creates a subclass of Transformer' do
+      expect(subclass).to be < Transproc::Transformer
+    end
+
+    it 'does not change super class' do
+      expect(klass.container).to be(container)
+    end
+
+    it 'does not inherit transproc' do
+      expect(klass[container].new.transproc).to be_nil
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(Transproc::Transformer[container]) do
+          container.import Transproc::Coercions
+          container.import Transproc::HashTransformations
+
+          map_value :attr, t(:to_symbol)
+        end
+      end
+
+      it "inherits parent's transproc" do
+        expect(klass[container].new.transproc).to eql(klass.new.transproc)
+      end
+    end
+  end
+
+  describe '.define' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+
+        def self.to_symbol(v)
+          v.to_sym
+        end
+      end
+    end
+
+    let(:klass) { Transproc::Transformer[container] }
+
+    it 'defines anonymous transproc' do
+      transproc = klass.define do
+        map_value(:attr, t(:to_symbol))
+      end
+
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'has .build alias' do
+      transproc = klass.build do
+        map_value(:attr, t(:to_symbol))
+      end
+
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'does not affect original transformer' do
+      klass.define do
+        map_value(:attr, :to_sym.to_proc)
+      end
+
+      expect(klass.new.transproc).to be_nil
+    end
+
+    context 'with custom container' do
+      let(:container) do
+        Module.new do
+          extend Transproc::Registry
+
+          def self.arbitrary(value, fn)
+            fn[value]
+          end
+        end
+      end
+
+      let(:klass) { described_class[container] }
+
+      it 'uses a container from the transformer' do
+        transproc = klass.define! do
+          arbitrary ->(v) { v + 1 }
+        end.new
+
+        expect(transproc.call(2)).to eq 3
+      end
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(described_class[container]) do
+          define! do
+            map_value :attr, ->(v) { v + 1 }
+          end
+        end
+      end
+
+      it 'builds transformation from the DSL definition' do
+        transproc = klass.new
+
+        expect(transproc.call(attr: 2)).to eql(attr: 3)
+      end
+    end
+  end
+
+  describe '.t' do
+    subject(:klass) { Transproc::Transformer[container] }
+
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::Conditional
+
+        def self.custom(value, suffix)
+          value + suffix
+        end
+      end
+    end
+
+    it 'returns a registed function' do
+      expect(klass.t(:custom, '_bar')).to eql(container[:custom, '_bar'])
+    end
+
+    it 'is useful in DSL' do
+      transproc = Class.new(klass) do
+        map_value :a, t(:custom, '_bar')
+      end.new
+
+      expect(transproc.call(a: 'foo')).to eq(a: 'foo_bar')
+    end
+
+    it 'works in nested block' do
+      transproc = Class.new(klass) do
+        map_values do
+          is String, t(:custom, '_bar')
+        end
+      end.new
+
+      expect(transproc.call(a: 'foo', b: :symbol)).to eq(a: 'foo_bar', b: :symbol)
+    end
+  end
+
+  describe '.method_missing' do
+    it 'responds to missing when there is a corresponding function' do
+      container.import Transproc::HashTransformations
+
+      expect(klass.method(:map_values)).to be_a(Method)
+    end
+
+    it 'raises when there is no corresponding function or instance method' do
+      expect { klass.not_here }.to raise_error(NoMethodError, /not_here/)
+    end
+  end
+
+  describe '#call' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::ArrayTransformations
+        import Transproc::ClassTransformations
+      end
+    end
+
+    let(:klass) do
+      Class.new(Transproc::Transformer[container]) do
+        map_array do
+          symbolize_keys
+          rename_keys user_name: :name
+          nest :address, [:city, :street, :zipcode]
+
+          map_value :address do
+            constructor_inject Test::Address
+          end
+
+          constructor_inject Test::User
+        end
+      end
+    end
+
+    let(:input) do
+      [
+        { 'user_name' => 'Jane',
+          'city' => 'NYC',
+          'street' => 'Street 1',
+          'zipcode' => '123'
+        }
+      ]
+    end
+
+    let(:expected_output) do
+      [
+        Test::User.new(
+          name: 'Jane',
+          address: Test::Address.new(
+            city: 'NYC',
+            street: 'Street 1',
+            zipcode: '123'
+          )
+        )
+      ]
+    end
+
+    before do
+      module Test
+        class User < OpenStruct
+          include Dry::Equalizer(:name, :address)
+        end
+
+        class Address < OpenStruct
+          include Dry::Equalizer(:city, :street, :zipcode)
+        end
+      end
+    end
+
+    it "transforms input" do
+      expect(transformer.(input)).to eql(expected_output)
+    end
+
+    context 'with custom registry' do
+      let(:klass) do
+        Class.new(Transproc::Transformer[registry]) do
+          append ' is awesome'
+        end
+      end
+
+      let(:registry) do
+        Module.new do
+          extend Transproc::Registry
+
+          def self.append(value, suffix)
+            value + suffix
+          end
+        end
+      end
+
+      it 'uses custom functions' do
+        expect(transformer.('transproc')).to eql('transproc is awesome')
+      end
+    end
+  end
+end