dry-transformer 0.1.0 → 0.1.1

data/spec/unit/proc_transformations_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'ostruct'
-
-RSpec.describe Dry::Transformer::ProcTransformations do
-  describe '.bind' do
-    let(:fn) { described_class.t(:bind, binding, proc) }
-    let(:binding) { OpenStruct.new(prefix: prefix) }
-    let(:proc) { -> v { [prefix, v].join('_') } }
-    let(:prefix) { 'foo' }
-    let(:input) { 'bar' }
-    let(:output) { 'foo_bar' }
-
-    subject  { fn[input] }
-
-    it 'binds the given proc to the specified binding' do
-      is_expected.to eq(output)
-    end
-  end
-end

data/spec/unit/recursion_spec.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::Recursion do
-  let(:hashes) { Dry::Transformer::HashTransformations }
-
-  describe '.recursion' do
-    let(:original) do
-      {
-        'foo' => 'bar',
-        'bar' => {
-          'foo' => 'bar',
-          'bar' => %w(foo bar baz),
-          'baz' => 'foo'
-        },
-        'baz' => 'bar'
-      }
-    end
-
-    let(:input) { original.dup }
-
-    let(:output) do
-      {
-        'foo' => 'bar',
-        'bar' => {
-          'foo' => 'bar',
-          'bar' => %w(foo bar)
-        }
-      }
-    end
-
-    context 'when function is non-destructive' do
-      let(:map) do
-        described_class.t(:recursion, -> enum {
-          enum.reject { |v| v == 'baz' }
-        })
-      end
-
-      it 'applies funtions to all items recursively' do
-        expect(map[input]).to eql(output)
-        expect(input).to eql(original)
-      end
-    end
-
-    context 'when function is destructive' do
-      let(:map) do
-        described_class.t(:recursion, -> enum {
-          enum.reject! { |v| v == 'baz' }
-        })
-      end
-
-      it 'applies funtions to all items recursively and destructively' do
-        expect(map[input]).to eql(output)
-        expect(input).to eql(output)
-      end
-    end
-  end
-
-  describe '.array_recursion' do
-    let(:original) do
-      [
-        'foo',
-        'bar',
-        nil,
-        [
-          'foo',
-          'bar',
-          nil,
-          [
-            'foo',
-            'bar',
-            nil
-          ]
-        ]
-      ]
-    end
-
-    let(:input) { original.dup }
-
-    let(:output) do
-      [
-        'foo',
-        'bar',
-        [
-          'foo',
-          'bar',
-          %w(foo bar)
-        ]
-      ]
-    end
-
-    context 'when function is non-destructive' do
-      let(:map) { described_class.t(:array_recursion, proc(&:compact)) }
-
-      it 'applies funtions to all items recursively' do
-        expect(map[input]).to eql(output)
-        expect(input).to eql(original)
-      end
-    end
-
-    context 'when function is destructive' do
-      let(:map) { described_class.t(:array_recursion, proc(&:compact!)) }
-
-      it 'applies funtions to all items recursively and destructively' do
-        expect(map[input]).to eql(output)
-        expect(input).to eql(output)
-      end
-    end
-  end
-
-  describe '.hash_recursion' do
-    let(:input) do
-      {
-        'foo' => 'bar',
-        'bar' => {
-          'foo' => 'bar',
-          'bar' => {
-            'foo' => 'bar'
-          }.freeze
-        }.freeze,
-        'baz' => 'bar'
-      }.freeze
-    end
-
-    let(:output) do
-      {
-        foo: 'bar',
-        bar: {
-          foo: 'bar',
-          bar: {
-            foo: 'bar'
-          }
-        },
-        baz: 'bar'
-      }
-    end
-
-    let(:map) do
-      described_class.t(:hash_recursion, hashes.t(:symbolize_keys))
-    end
-
-    it 'applies funtions to all values recursively' do
-      expect(map[input]).to eql(output)
-    end
-  end
-end

data/spec/unit/registry_spec.rb

@@ -1,202 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::Registry do
-  let(:foo) do
-    Test::Foo = Module.new do
-      extend Dry::Transformer::Registry
-
-      def self.prefix(value, prefix)
-        "#{prefix}_#{value}"
-      end
-    end
-  end
-
-  let(:bar) { Test::Bar = Module.new { extend Dry::Transformer::Registry } }
-  let(:baz) { Test::Baz = Module.new { extend Dry::Transformer::Registry } }
-
-  describe '.[]' do
-    subject(:transproc) { foo[fn, 'baz'] }
-
-    context 'from a method' do
-      let(:fn) { :prefix }
-
-      it 'builds a function from a method' do
-        expect(transproc['qux']).to eql 'baz_qux'
-      end
-    end
-
-    context 'from a closure' do
-      let(:fn) { -> value, prefix { [prefix, '_', value].join } }
-
-      it 'builds a function from a method' do
-        expect(transproc['qux']).to eql 'baz_qux'
-      end
-    end
-  end
-
-  describe '.t' do
-    subject(:transproc) { foo.t(:prefix, 'baz') }
-
-    it 'is an alias for .[]' do
-      expect(transproc['qux']).to eql 'baz_qux'
-    end
-  end
-
-  describe '.contain?' do
-    context 'with absent function' do
-      it { expect(foo.contain?(:something)).to be false }
-    end
-
-    context 'with class method' do
-      it { expect(foo.contain?(:prefix)).to be true }
-    end
-
-    context 'with imported methods' do
-      before { bar.import foo }
-
-      it { expect(bar.contain?(:prefix)).to be true }
-    end
-  end
-
-  describe '.register' do
-    it { expect(foo).not_to be_contain(:increment) }
-
-    it { expect(foo).to be_contain(:prefix) }
-
-    def do_register
-      foo.register(:increment, ->(v) { v + 1 })
-    end
-
-    it 'returns self' do
-      expect(do_register).to eq foo
-    end
-
-    it 'registers function' do
-      do_register
-      expect(foo).to be_contain(:increment)
-    end
-
-    it 'preserves previous functions' do
-      do_register
-      expect(foo).to be_contain(:prefix)
-    end
-
-    it 'makes function available' do
-      do_register
-      expect(foo[:increment][2]).to eq 3
-    end
-
-    it 'rejects to overwrite existing' do
-      expect { foo.register(:prefix) {} }
-        .to raise_error(Dry::Transformer::FunctionAlreadyRegisteredError)
-    end
-
-    it 'registers and fetches transproc function' do
-      function = foo[:prefix, '1']
-      foo.register(:prefix_one, function)
-
-      expect(foo[:prefix_one]).to eq function
-    end
-
-    it 'allows to overwrite function arguments' do
-      foo.register(:map_array, Dry::Transformer::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)
-
-      expect(foo[:double_prefix]).to eq composite
-    end
-
-    context 'with block argument' do
-      def do_register
-        foo.register(:increment) { |v| v + 1 }
-      end
-
-      it 'registers function' do
-        do_register
-        expect(foo).to be_contain(:increment)
-      end
-
-      it 'makes function available' do
-        do_register
-        expect(foo[:increment][2]).to eq 3
-      end
-    end
-  end
-
-  describe '.import' do
-    context 'a module' do
-      subject(:import) { bar.import foo }
-
-      it 'registers all its methods' do
-        import
-        expect(bar[:prefix, 'baz']['qux']).to eql 'baz_qux'
-      end
-
-      it 'returns itself' do
-        expect(import).to eq bar
-      end
-    end
-
-    context 'a method' do
-      before { bar.import :prefix, from: foo }
-
-      it 'registers a transproc' do
-        expect(bar[:prefix, 'bar']['baz']).to eql 'bar_baz'
-      end
-    end
-
-    context 'an imported method' do
-      before do
-        bar.import :prefix, from: foo, as: :affix
-        baz.import :affix, from: bar
-      end
-
-      it 'registers a transproc' do
-        expect(baz[:affix, 'bar']['baz']).to eql 'bar_baz'
-      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 }
-
-      it 'registers a transproc under the new name' do
-        expect(bar[:affix, 'bar']['baz']).to eql 'bar_baz'
-      end
-    end
-
-    context 'an unknown method' do
-      it 'fails' do
-        expect { bar.import :suffix, from: foo }.to raise_error do |error|
-          expect(error).to be_kind_of Dry::Transformer::FunctionNotFoundError
-          expect(error.message).to include 'Foo[:suffix]'
-        end
-      end
-    end
-  end
-
-  describe '.uses' do
-    before { bar.uses foo }
-
-    it 'is an alias for .import' do
-      expect(bar[:prefix, 'baz']['qux']).to eql 'baz_qux'
-    end
-  end
-end

data/spec/unit/store_spec.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Dry::Transformer::Store do
-  let(:store) { described_class.new methods      }
-  let(:methods) { { foo: instance_double(Proc) } }
-
-  describe '.new' do
-    it 'is immutable' do
-      expect(store).to be_frozen
-    end
-
-    it 'does not freeze the source hash' do
-      expect { store }.not_to change { methods.frozen? }
-    end
-  end # describe .new
-
-  describe '#methods' do
-    it 'returns the hash from the initializer' do
-      expect(store.methods).to eql methods
-    end
-
-    it 'returns empty hash by default' do
-      expect(described_class.new.methods).to eql({})
-    end
-
-    it 'is immutable' do
-      expect(store.methods).to be_frozen
-    end
-  end # describe #methods
-
-  describe '#fetch' do
-    it 'returns a registered proc' do
-      expect(store.fetch(:foo)).to eql methods[:foo]
-    end
-
-    it 'does not accepts anything but symbol as key' do
-      expect { store.fetch('foo') }.to raise_error KeyError
-    end
-
-    it 'raises KeyError if requested proc is unknown' do
-      expect { store.fetch(:bar) }.to raise_error KeyError
-    end
-  end # describe #fetch
-
-  describe '#contain?' do
-    it 'returns true for registered proc' do
-      expect(store.contain?(:foo)).to be true
-    end
-
-    it 'returns false if requested proc is unknown' do
-      expect(store.contain?(:bar)).to be false
-    end
-  end # describe #fetch
-
-  describe '#register' do
-    subject { new_store }
-    let(:new_store) { store.register(:increment, ->(v) { v + 1 }) }
-
-    it { is_expected.to be_contain(:increment) }
-
-    it { expect(new_store.fetch(:increment)[2]).to eq 3 }
-
-    it 'preserves existing methods' do
-      expect(new_store).to be_contain(:foo)
-    end
-
-    context 'with block argument' do
-      let(:new_store) { store.register(:increment) { |v| v + 1 } }
-
-      it 'works as well as with proc' do
-        expect(new_store.fetch(:increment)[2]).to eq 3
-      end
-    end
-  end
-
-  describe '#import', :focus do
-    before do
-      module Bar
-        def self.bar
-          :bar
-        end
-      end
-
-      module Baz
-        def self.baz
-          :baz
-        end
-      end
-
-      module Qux
-        extend Dry::Transformer::Registry
-
-        import Bar
-        import Baz
-
-        def self.baz
-          :qux_baz
-        end
-
-        def self.qux
-          :qux
-        end
-      end
-    end
-
-    shared_examples :importing_method do
-      let(:preserved) { subject.methods[:foo] }
-      let(:imported)  { subject.methods[key]  }
-
-      it '[preserves old methods]' do
-        expect(preserved).to eql(methods[:foo])
-      end
-
-      it '[registers a new method]' do
-        expect(imported).to be_kind_of Method
-        expect(imported.call).to eql(value)
-      end
-    end
-
-    context 'named method' do
-      subject { store.import 'qux', from: Qux }
-
-      it_behaves_like :importing_method do
-        let(:key)   { :qux }
-        let(:value) { :qux }
-      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' }
-
-      it_behaves_like :importing_method do
-        let(:key)   { :quxx }
-        let(:value) { :qux  }
-      end
-    end
-
-    context 'imported proc' do
-      subject { store.import 'bar', from: Qux, as: 'barr' }
-
-      it_behaves_like :importing_method do
-        let(:key)   { :barr }
-        let(:value) { :bar  }
-      end
-    end
-
-    context 'method that reloads imported proc' do
-      subject { store.import 'baz', from: Qux, as: 'bazz' }
-
-      it_behaves_like :importing_method do
-        let(:key)   { :bazz    }
-        let(:value) { :qux_baz }
-      end
-    end
-
-    context 'module' do
-      subject { store.import Qux }
-
-      it_behaves_like :importing_method do
-        let(:key)   { :bar }
-        let(:value) { :bar }
-      end
-
-      it_behaves_like :importing_method do
-        let(:key)   { :baz     }
-        let(:value) { :qux_baz }
-      end
-
-      it_behaves_like :importing_method do
-        let(:key)   { :qux }
-        let(:value) { :qux }
-      end
-
-      it 'skips Dry::Transformer::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
-
-    after do
-      %w(Bar Baz Qux).each { |name| Object.send :remove_const, name }
-    end
-  end # describe #import
-end # describe Dry::Transformer::Store