dry-transformer 0.1.0 → 1.0.0

data/spec/unit/array/combine_spec.rb

@@ -1,224 +0,0 @@
-# frozen_string_literal: true
-
-require 'forwardable'
-
-RSpec.describe Dry::Transformer::ArrayTransformations do
-  describe '.combine' do
-    subject(:result) { described_class.t(:combine, mappings)[input] }
-
-    let(:input) { [[]] }
-    let(:mappings) { [] }
-
-    it { is_expected.to be_a(Array) }
-
-    it { is_expected.to eq([]) }
-
-    context 'without groups' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze
-        ].freeze
-      end
-
-      it { is_expected.to eq input.first }
-    end
-
-    context 'with one group' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze,
-          [
-            [
-              {user: 'Jane', title: 'One'}.freeze,
-              {user: 'Jane', title: 'Two'}.freeze,
-              {user: 'Joe', title: 'Three'}.freeze
-            ]
-          ]
-        ].freeze
-      end
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it 'merges hashes from arrays using provided join keys' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', title: 'One'},
-            {user: 'Jane', title: 'Two'}
-          ]},
-          {name: 'Joe', email: 'joe@doe.org', tasks: [
-            {user: 'Joe', title: 'Three'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    context 'with empty nodes' do
-      let(:input) do
-        [
-          [{name: 'Jane', email: 'jane@doe.org'}.freeze].freeze,
-          [
-            []
-          ]
-        ].freeze
-      end
-
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it { is_expected.to eq([{name: 'Jane', email: 'jane@doe.org', tasks: []}]) }
-    end
-
-    context 'with double mapping' do
-      let(:input) do
-        [
-          [
-            {name: 'Jane', email: 'jane@doe.org'}.freeze
-          ].freeze,
-          [
-            [
-              {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}.freeze,
-              {user: 'Jane', user_email: '', title: 'Two'}.freeze
-            ].freeze
-          ].freeze
-        ].freeze
-      end
-
-      let(:mappings) { [[:tasks, {name: :user, email: :user_email}]] }
-
-      it 'searches by two keys simultaneously' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', user_email: 'jane@doe.org', title: 'One'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    context 'with non-array argument' do
-      let(:input) do
-        123
-      end
-
-      let(:mappings) { [[:page, {page_id: :id}]] }
-
-      it { is_expected.to eq(123) }
-    end
-
-    context 'with empty nested array' do
-      let(:input) do
-        [
-          [],
-          [
-            []
-          ]
-        ]
-      end
-
-      let(:mappings) { [[:menu_items, {id: :menu_id}, [[:page, {page_id: :id}]]]] }
-
-      it 'does not crash' do
-        expect { result }.not_to raise_error
-      end
-    end
-
-    context 'with enumerable input' do
-      let(:my_enumerator) do
-        Class.new do
-          include Enumerable
-          extend Forwardable
-
-          def_delegator :@array, :each
-
-          def initialize(array)
-            @array = array
-          end
-        end
-      end
-
-      let(:input) do
-        [
-          my_enumerator.new([
-            {name: 'Jane', email: 'jane@doe.org'}.freeze,
-            {name: 'Joe', email: 'joe@doe.org'}.freeze
-          ].freeze),
-          my_enumerator.new([
-            my_enumerator.new([
-              {user: 'Jane', title: 'One'}.freeze,
-              {user: 'Jane', title: 'Two'}.freeze,
-              {user: 'Joe', title: 'Three'}.freeze
-            ].freeze)
-          ].freeze)
-        ].freeze
-      end
-      let(:mappings) { [[:tasks, {name: :user}]] }
-
-      it 'supports enumerables as well' do
-        output = [
-          {name: 'Jane', email: 'jane@doe.org', tasks: [
-            {user: 'Jane', title: 'One'},
-            {user: 'Jane', title: 'Two'}
-          ]},
-          {name: 'Joe', email: 'joe@doe.org', tasks: [
-            {user: 'Joe', title: 'Three'}
-          ]}
-        ]
-        is_expected.to eql(output)
-      end
-    end
-
-    describe 'integration test' do
-      let(:input) do
-        [
-          [
-            {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'}
-                ]
-              ]
-            ]
-          ]
-        ]
-      end
-
-      let(:mappings) { [[:tasks, {name: :user}, [[:tags, title: :task]]]] }
-
-      it 'merges hashes from arrays using provided join keys' do
-        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'}
-                ]
-              }
-            ]
-          }
-        ]
-        is_expected.to eql(output)
-      end
-    end
-  end
-end

data/spec/unit/array_transformations_spec.rb

@@ -1,233 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::ArrayTransformations do
-  let(:hashes) { Dry::Transformer::HashTransformations }
-
-  describe '.extract_key' do
-    it 'extracts values by key from all hashes' do
-      extract_key = described_class.t(:extract_key, 'name')
-
-      input = [
-        { 'name' => 'Alice', 'role' => 'sender' },
-        { 'name' => 'Bob', 'role' => 'receiver' },
-        { 'role' => 'listener' }
-      ].freeze
-
-      output = ['Alice', 'Bob', nil]
-
-      expect(extract_key[input]).to eql(output)
-    end
-  end
-
-  it { expect(described_class).not_to be_contain(:extract_key!) }
-
-  describe '.insert_key' do
-    it 'wraps values to tuples with given key' do
-      insert_key = described_class.t(:insert_key, 'name')
-
-      input = ['Alice', 'Bob', nil].freeze
-
-      output = [
-        { 'name' => 'Alice' },
-        { 'name' => 'Bob' },
-        { 'name' => nil }
-      ]
-
-      expect(insert_key[input]).to eql(output)
-    end
-  end
-
-  it { expect(described_class).not_to be_contain(:insert_key!) }
-
-  describe '.add_keys' do
-    it 'returns a new array with missed keys added to tuples' do
-      add_keys = described_class.t(:add_keys, [:foo, :bar, :baz])
-
-      input = [{ foo: 'bar' }, { bar: 'baz' }].freeze
-
-      output = [
-        { foo: 'bar', bar: nil, baz: nil },
-        { foo: nil, bar: 'baz', baz: nil }
-      ]
-
-      expect(add_keys[input]).to eql(output)
-    end
-  end
-
-  it { expect(described_class).not_to be_contain(:add_keys!) }
-
-  describe '.map_array' do
-    it 'applies funtions to all values' do
-      map = described_class.t(:map_array, hashes[:symbolize_keys])
-
-      input = [
-        { 'name' => 'Jane', 'title' => 'One' }.freeze,
-        { 'name' => 'Jane', 'title' => 'Two' }.freeze
-      ].freeze
-
-      output = [
-        { name: 'Jane', title: 'One' },
-        { name: 'Jane', title: 'Two' }
-      ]
-
-      expect(map[input]).to eql(output)
-    end
-
-    it 'handles huge arrays' do
-      map = described_class.t(:map_array, hashes[:symbolize_keys])
-
-      input = Array.new(138_706) { |i| { 'key' => i } }
-
-      expect { map[input] }.to_not raise_error
-    end
-
-    it 'handles flat value arrays' do
-      map = described_class.t(:map_array, :upcase.to_proc)
-
-      expect(map['foo']).to eql(%w(FOO))
-    end
-  end
-
-  it { expect(described_class).not_to be_contain(:map_array!) }
-
-  describe '.wrap' do
-    it 'returns a new array with wrapped hashes' do
-      wrap = described_class.t(:wrap, :task, [:title])
-
-      input = [{ name: 'Jane', title: 'One' }]
-      output = [{ name: 'Jane', task: { title: 'One' } }]
-
-      expect(wrap[input]).to eql(output)
-    end
-
-    it 'returns a array new with deeply wrapped hashes' do
-      wrap =
-        described_class.t(
-          :map_array,
-          hashes[:nest, :user, [:name, :title]] +
-          hashes[:map_value, :user, hashes[:nest, :task, [:title]]]
-        )
-
-      input = [{ name: 'Jane', title: 'One' }]
-      output = [{ user: { name: 'Jane', task: { title: 'One' } } }]
-
-      expect(wrap[input]).to eql(output)
-    end
-
-    it 'adds data to the existing tuples' do
-      wrap = described_class.t(:wrap, :task, [:title])
-
-      input  = [{ name: 'Jane', task: { priority: 1 }, title: 'One' }]
-      output = [{ name: 'Jane', task: { priority: 1, title: 'One' } }]
-
-      expect(wrap[input]).to eql(output)
-    end
-  end
-
-  describe '.group' do
-    subject(:group) { described_class.t(:group, :tasks, [:title]) }
-
-    it 'returns a new array with grouped hashes' do
-      input  = [{ name: 'Jane', title: 'One' }, { name: 'Jane', title: 'Two' }]
-      output = [{ name: 'Jane', tasks: [{ title: 'One' }, { title: 'Two' }] }]
-
-      expect(group[input]).to eql(output)
-    end
-
-    it 'updates the existing group' do
-      input  = [
-        {
-          name: 'Jane',
-          title: 'One',
-          tasks: [{ type: 'one' }, { type: 'two' }]
-        },
-        {
-          name: 'Jane',
-          title: 'Two',
-          tasks: [{ type: 'one' }, { type: 'two' }]
-        }
-      ]
-      output = [
-        {
-          name: 'Jane',
-          tasks: [
-            { title: 'One', type: 'one' },
-            { title: 'One', type: 'two' },
-            { title: 'Two', type: 'one' },
-            { title: 'Two', type: 'two' }
-          ]
-        }
-      ]
-
-      expect(group[input]).to eql(output)
-    end
-
-    it 'ingnores old values except for array of tuples' do
-      input  = [
-        { name: 'Jane', title: 'One',   tasks: [{ priority: 1 }, :wrong] },
-        { name: 'Jane', title: 'Two',   tasks: :wrong }
-      ]
-      output = [
-        {
-          name: 'Jane',
-          tasks: [{ title: 'One', priority: 1 }, { title: 'Two' }]
-        }
-      ]
-
-      expect(group[input]).to eql(output)
-    end
-  end
-
-  describe '.ungroup' do
-    subject(:ungroup) { described_class.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
-
-    it 'ungroups array partially' do
-      input = [
-        {
-          name: 'Jane',
-          tasks: [
-            { title: 'One', type: 'one' },
-            { title: 'One', type: 'two' },
-            { title: 'Two', type: 'one' },
-            { title: 'Two', type: 'two' }
-          ]
-        }
-      ]
-      output = [
-        {
-          name: 'Jane',
-          title: 'One',
-          tasks: [{ type: 'one' }, { type: 'two' }]
-        },
-        {
-          name: 'Jane',
-          title: 'Two',
-          tasks: [{ type: 'one' }, { type: 'two' }]
-        }
-      ]
-
-      expect(ungroup[input]).to eql(output)
-    end
-  end
-end

data/spec/unit/class_transformations_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'dry/equalizer'
-
-RSpec.describe Dry::Transformer::ClassTransformations do
-  describe '.constructor_inject' do
-    let(:klass) do
-      Struct.new(:name, :age) { include Dry::Equalizer.new(:name, :age) }
-    end
-
-    it 'returns a new object initialized with the given arguments' do
-      constructor_inject = described_class.t(:constructor_inject, klass)
-
-      input = ['Jane', 25]
-      output = klass.new(*input)
-      result = constructor_inject[*input]
-
-      expect(result).to eql(output)
-      expect(result).to be_instance_of(klass)
-    end
-  end
-
-  describe '.set_ivars' do
-    let(:klass) do
-      Class.new do
-        include Dry::Equalizer.new(:name, :age)
-
-        attr_reader :name, :age, :test
-
-        def initialize(name:, age:)
-          @name = name
-          @age = age
-          @test = true
-        end
-      end
-    end
-
-    it 'allocates a new object and sets instance variables from hash key/value pairs' do
-      set_ivars = described_class.t(:set_ivars, klass)
-
-      input = { name: 'Jane', age: 25 }
-      output = klass.new(input)
-      result = set_ivars[input]
-
-      expect(result).to eql(output)
-      expect(result.test).to be(nil)
-      expect(result).to be_instance_of(klass)
-    end
-  end
-end

data/spec/unit/coercions_spec.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::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')
-    end
-  end
-
-  describe '.to_symbol' 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
-    it 'turns string into an integer' do
-      expect(described_class.t(:to_integer)['1']).to eql(1)
-    end
-  end
-
-  describe '.to_float' do
-    it 'turns string into a float' do
-      expect(described_class.t(:to_float)['1']).to eql(1.0)
-    end
-
-    it 'turns integer into a float' do
-      expect(described_class.t(:to_float)[1]).to eql(1.0)
-    end
-  end
-
-  describe '.to_decimal' do
-    it 'turns string into a decimal' do
-      expect(described_class.t(:to_decimal)['1.251']).to eql(BigDecimal('1.251'))
-    end
-
-    it 'turns float into a decimal' do
-      expect(described_class.t(:to_decimal)[1.251]).to eql(BigDecimal('1.251'))
-    end
-
-    it 'turns integer into a decimal' do
-      expect(described_class.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(described_class.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(described_class.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(described_class.t(:to_datetime)['2012-01-23 11:07:07']).to eql(datetime)
-    end
-  end
-
-  describe '.to_boolean' do
-    subject(:coercer) { described_class.t(:to_boolean) }
-
-    Dry::Transformer::Coercions::TRUE_VALUES.each do |value|
-      it "turns #{value.inspect} to true" do
-        expect(coercer[value]).to be(true)
-      end
-    end
-
-    Dry::Transformer::Coercions::FALSE_VALUES.each do |value|
-      it "turns #{value.inspect} to false" do
-        expect(coercer[value]).to be(false)
-      end
-    end
-  end
-
-  describe '.to_tuples' do
-    subject(:to_tuples) { described_class.t(:to_tuples) }
-
-    context 'non-array' do
-      let(:input) { :foo }
-
-      it 'returns an array with one blank tuple' do
-        output = [{}]
-
-        expect(to_tuples[input]).to eql(output)
-      end
-    end
-
-    context 'empty array' do
-      let(:input) { [] }
-
-      it 'returns an array with one blank tuple' do
-        output = [{}]
-
-        expect(to_tuples[input]).to eql(output)
-      end
-    end
-
-    context 'array of tuples' do
-      let(:input) { [:foo, { bar: :BAZ }, :qux] }
-
-      it 'returns an array with tuples only' do
-        output = [{ bar: :BAZ }]
-
-        expect(to_tuples[input]).to eql(output)
-      end
-    end
-  end
-end

data/spec/unit/conditional_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::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) } }
-    let(:operation) { Dry::Transformer::Coercions.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/unit/function_not_found_error_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::FunctionNotFoundError do
-  it 'complains that the function not registered' do
-    Foo = Module.new { extend Dry::Transformer::Registry }
-
-    expect { Foo[:foo] }.to raise_error do |error|
-      expect(error).to be_kind_of described_class
-      expect(error.message['function Foo[:foo]']).not_to be_nil
-    end
-  end
-end