dry-transformer 0.1.0 → 0.1.1

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