transproc 0.4.2 → 1.0.0

data/spec/unit/recursion_spec.rb

@@ -108,21 +108,19 @@ describe Transproc::Recursion do
   end
 
   describe '.hash_recursion' do
-    let(:original) do
+    let(:input) do
       {
         'foo' => 'bar',
         'bar' => {
           'foo' => 'bar',
           'bar' => {
             'foo' => 'bar'
-          }
-        },
+          }.freeze
+        }.freeze,
         'baz' => 'bar'
-      }
+      }.freeze
     end
 
-    let(:input) { original.dup }
-
     let(:output) do
       {
         foo: 'bar',
@@ -136,26 +134,12 @@ describe Transproc::Recursion do
       }
     end
 
-    context 'when function is non-destructive' do
-      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)
-        expect(input).to eql(original)
-      end
+    let(:map) do
+      described_class.t(:hash_recursion, hashes.t(:symbolize_keys))
     end
 
-    context 'when function is destructive' do
-      let(:map) do
-        described_class.t(:hash_recursion, hashes.t(:symbolize_keys!))
-      end
-
-      it 'applies funtions to all values recursively and destructively' do
-        expect(map[input]).to eql(output)
-        expect(input).to eql(output)
-      end
+    it 'applies funtions to all values recursively' do
+      expect(map[input]).to eql(output)
     end
   end
 end

data/spec/unit/registry_spec.rb

@@ -44,6 +44,86 @@ describe Transproc::Registry do
     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(Transproc::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 '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 }

data/spec/unit/store_spec.rb

@@ -33,11 +33,46 @@ describe Transproc::Store 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

data/spec/unit/transformer_spec.rb

@@ -1,15 +1,20 @@
 require 'spec_helper'
 
 describe Transproc::Transformer do
-  let(:klass) { Class.new(Transproc::Transformer) }
+  let(:container) { Module.new { extend Transproc::Registry } }
+  let(:klass) { Transproc::Transformer[container] }
   let(:transformer) { klass.new }
 
   describe '.container' do
-    context 'without setter argument' do
-      subject! { klass.container }
+    it { expect(klass.container).to eq container }
 
-      it 'defaults to Transproc' do
-        is_expected.to eq(Transproc)
+    context 'with default transformer' do
+      let(:klass) { described_class }
+
+      it 'raises exception because there is no container by default' do
+        message = 'Transformer function registry is empty. '\
+                  'Provide your registry via Transproc::Transformer[YourRegistry]'
+        expect { klass.container }.to raise_error(ArgumentError, message)
       end
     end
 
@@ -22,18 +27,189 @@ describe Transproc::Transformer do
     end
   end
 
+  describe 'inheritance' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        def self.arbitrary(value, fn)
+          fn[value]
+        end
+      end
+    end
+    let(:superclass) do
+      Class.new(Transproc::Transformer[container]) do
+        arbitrary ->(v) { v + 1 }
+      end
+    end
+    let(:subclass) do
+      Class.new(superclass) do
+        arbitrary ->(v) { v * 2 }
+      end
+    end
+
+    it 'inherits container from superclass' do
+      expect(subclass.container).to eq superclass.container
+    end
+
+    it 'does not inherit transproc from superclass' do
+      expect(superclass.new.call(2)).to eq 3
+      expect(subclass.new.call(2)).to eq 4
+    end
+  end
+
   describe '.[]' do
-    let(:container) { double('Transproc') }
+    let(:another_container) { double('Transproc') }
 
-    subject!(:klass) { Transproc::Transformer[container] }
+    subject(:subclass) { klass[another_container] }
 
-    it { expect(klass.container).to eq(container) }
+    it { expect(subclass.container).to eq(another_container) }
     it { is_expected.to be_a(::Class) }
+    it { expect(subclass.ancestors).to include(Transproc::Transformer) }
+
+    it 'does not change super class' do
+      expect(klass.container).to eq(container)
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(Transproc::Transformer) do
+          map_value :attr, t(:to_symbol)
+        end
+      end
+    end
+
+    it 'does not inherit transproc' do
+      expect(klass[container].transproc).to be_nil
+    end
+  end
+
+  describe '.define' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+
+        def self.to_symbol(v)
+          v.to_sym
+        end
+      end
+    end
+    let(:klass) { Transproc::Transformer[container] }
+
+    it 'defines anonymous transproc' do
+      transproc = klass.define do
+        map_value(:attr, t(:to_symbol))
+      end
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'has .build alias' do
+      transproc = klass.build do
+        map_value(:attr, t(:to_symbol))
+      end
+      expect(transproc[attr: 'abc']).to eq(attr: :abc)
+    end
+
+    it 'does not affect original transformer' do
+      klass.define do
+        map_value(:attr, :to_sym.to_proc)
+      end
+      expect(klass.transproc).to be_nil
+    end
+
+    context 'with custom container' do
+      let(:container) do
+        Module.new do
+          extend Transproc::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
+        expect(transproc.call(2)).to eq 3
+      end
+    end
+
+    context 'with predefined transformer' do
+      let(:klass) do
+        Class.new(described_class[container]) do
+          map_value :attr, ->(v) { v + 1 }
+        end
+      end
+
+      it 'just initializes transformer if no block was given' do
+        transproc = klass.define
+        expect(transproc.call(attr: 2)).to eq(attr: 3)
+      end
+
+      it 'does not inherit transproc from superclass' do
+        transproc = klass.define do
+          map_value :attr, ->(v) { v * 2 }
+        end
+        expect(transproc.call(attr: 2)).to eq(attr: 4)
+      end
+    end
+  end
+
+  describe '.t' do
+    let(:container) do
+      Module.new do
+        extend Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::Conditional
+
+        def self.custom(value, suffix)
+          value + suffix
+        end
+      end
+    end
+
+    subject!(:klass) { Transproc::Transformer[container] }
+
+    it { expect(klass.t(:custom, '_bar')).to eq container[:custom, '_bar'] }
+
+    it 'is useful in DSL' do
+      transproc = Class.new(klass) 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) 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 Transproc::Registry
+
+        import Transproc::HashTransformations
+        import Transproc::ArrayTransformations
+        import Transproc::ClassTransformations
+      end
+    end
+
     let(:klass) do
-      Class.new(Transproc::Transformer) do
+      Class.new(Transproc::Transformer[container]) do
         map_array do
           symbolize_keys
           rename_keys user_name: :name
@@ -82,5 +258,25 @@ describe Transproc::Transformer do
     subject! { transformer.call(input) }
 
     it { is_expected.to eq(output) }
+
+    context 'with custom registry' do
+      let(:klass) do
+        Class.new(Transproc::Transformer[registry]) do
+          custom ' is awesome'
+        end
+      end
+      let(:registry) do
+        Module.new do
+          extend Transproc::Registry
+
+          def self.custom(value, suffix)
+            value + suffix
+          end
+        end
+      end
+      let(:input) { 'transproc' }
+
+      it { is_expected.to eq('transproc is awesome') }
+    end
   end
 end

data/spec/unit/transproc_spec.rb

@@ -6,55 +6,12 @@ describe Transproc do
       input = '1'
       output = 1.0
 
-      to_i = t(-> value { value.to_i })
-      to_f = t(-> value { value.to_f })
+      to_i = Transproc::Function.new(->(value) { value.to_i })
+      to_f = Transproc::Function.new(->(value) { value.to_f })
 
       result = to_i >> to_f
 
       expect(result[input]).to eql(output)
     end
   end
-
-  describe '.register' do
-    it 'allows registering functions by name' do
-      Transproc.register(:id, -> value { value })
-
-      value = 'hello world'
-
-      result = t(:id)[value]
-
-      expect(result).to be(value)
-    end
-
-    it 'allows registering function by passing a block' do
-      Transproc.register(:to_boolean1) { |value| value == 'true' }
-
-      result = t(-> value { value.to_s }) >> t(:to_boolean1)
-
-      expect(result[:true]).to be(true)
-      expect(result[:false]).to be(false)
-    end
-
-    it 'raises a Transproc::FunctionAlreadyRegisteredError if a function is already registered' do
-      Transproc.register(:bogus) {}
-      expect { Transproc.register(:bogus) {} }.to raise_error(Transproc::FunctionAlreadyRegisteredError)
-    end
-  end
-
-  describe 'nonextistent functions' do
-    it 'raises a Transproc::FunctionNotFoundError if asking for function that is non exsistent' do
-      expect {
-        Transproc(:i_do_not_exist)
-        raise('expected the :i_do_not_exist function to not exist')
-      }.to raise_error(Transproc::FunctionNotFoundError)
-    end
-  end
-
-  describe 'accessing a function with args' do
-    it 'curries the args' do
-      fn = Transproc(:map_array, Transproc(:to_string))
-
-      expect(fn.args).to include(Transproc(:to_string))
-    end
-  end
 end