dry-transformer 0.1.0 → 0.1.1

data/spec/unit/transformer/class_interface_spec.rb

@@ -1,350 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-require 'dry/equalizer'
-
-RSpec.describe Dry::Transformer do
-  let(:container) { Module.new { extend Dry::Transformer::Registry } }
-  let(:klass) { Dry::Transformer[container] }
-  let(:transformer) { klass.new }
-
-  describe '.import' do
-    it 'allows importing functions into an auto-configured registry' do
-      klass = Class.new(Dry::Transformer::Pipe) do
-        import Dry::Transformer::ArrayTransformations
-        import Dry::Transformer::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(Dry::Transformer::Pipe) do
-        import Dry::Transformer::ArrayTransformations
-        import Dry::Transformer::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 Dry::Transformer::Registry
-
-        def self.arbitrary(value, fn)
-          fn[value]
-        end
-      end
-    end
-
-    let(:superclass) do
-      Class.new(Dry::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('Dry::Transformer') }
-
-    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 < Dry::Transformer::Pipe
-    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(Dry::Transformer[container]) do
-          container.import Dry::Transformer::Coercions
-          container.import Dry::Transformer::HashTransformations
-
-          define! do
-            map_value :attr, t(:to_symbol)
-          end
-        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 Dry::Transformer::Registry
-
-        import Dry::Transformer::HashTransformations
-
-        def self.to_symbol(v)
-          v.to_sym
-        end
-      end
-    end
-
-    let(:klass) { Dry::Transformer[container] }
-
-    it 'defines anonymous transproc' do
-      transproc = klass.define! do
-        map_value(:attr, t(:to_symbol))
-      end
-
-      expect(transproc.new.transproc[attr: 'abc']).to eq(attr: :abc)
-    end
-
-    it 'does not affect original transformer' do
-      Class.new(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 Dry::Transformer::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) { Dry::Transformer[container] }
-
-    let(:container) do
-      Module.new do
-        extend Dry::Transformer::Registry
-
-        import Dry::Transformer::HashTransformations
-        import Dry::Transformer::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).define! 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).define! 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 '#call' do
-    let(:container) do
-      Module.new do
-        extend Dry::Transformer::Registry
-
-        import Dry::Transformer::HashTransformations
-        import Dry::Transformer::ArrayTransformations
-        import Dry::Transformer::ClassTransformations
-      end
-    end
-
-    let(:klass) do
-      Class.new(Dry::Transformer[container]) do
-        define! 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
-    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(Dry::Transformer[registry]) do
-          define! do
-            append ' is awesome'
-          end
-        end
-      end
-
-      let(:registry) do
-        Module.new do
-          extend Dry::Transformer::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

data/spec/unit/transformer/dsl_spec.rb

@@ -1,15 +0,0 @@
-RSpec.describe Dry::Transformer do
-  let(:container) { Module.new { extend Dry::Transformer::Registry } }
-  let(:klass) { Dry::Transformer[container] }
-  let(:transformer) { klass.new }
-
-  context 'when invalid method is used' do
-    it 'raises an error on initialization' do
-      klass.define! do
-        not_valid
-      end
-
-      expect { klass.new }.to raise_error(Dry::Transformer::Compiler::InvalidFunctionNameError, /not_valid/)
-    end
-  end
-end

data/spec/unit/transformer/instance_methods_spec.rb

@@ -1,25 +0,0 @@
-RSpec.describe Dry::Transformer, 'instance methods' do
-  subject(:transformer) do
-    Class.new(Dry::Transformer[registry]) do
-      define! do
-        map_array(&:capitalize)
-      end
-
-      def capitalize(input)
-        input.upcase
-      end
-    end.new
-  end
-
-  let(:registry) do
-    Module.new do
-      extend Dry::Transformer::Registry
-
-      import Dry::Transformer::ArrayTransformations
-    end
-  end
-
-  it 'registers a new transformation function' do
-    expect(transformer.call(%w[foo bar])).to eql(%w[FOO BAR])
-  end
-end