dry-transformer 0.1.0

data/spec/unit/proc_transformations_spec.rb

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,145 @@
+# 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

@@ -0,0 +1,202 @@
+# 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

@@ -0,0 +1,198 @@
+# 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