transproc 0.2.4 → 0.3.0

data/spec/unit/recursion_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Transproc::Recursion do
+  let(:hashes) { Transproc::HashTransformations }
+
   describe '.recursion' do
     let(:original) do
       {
@@ -28,7 +30,7 @@ describe Transproc::Recursion do
 
     context 'when function is non-destructive' do
       let(:map) do
-        t(:recursion, -> enum {
+        described_class.t(:recursion, -> enum {
           enum.reject { |v| v == 'baz' }
         })
       end
@@ -41,7 +43,7 @@ describe Transproc::Recursion do
 
     context 'when function is destructive' do
       let(:map) do
-        t(:recursion, -> enum {
+        described_class.t(:recursion, -> enum {
           enum.reject! { |v| v == 'baz' }
         })
       end
@@ -87,7 +89,7 @@ describe Transproc::Recursion do
     end
 
     context 'when function is non-destructive' do
-      let(:map) { t(:array_recursion, proc(&:compact)) }
+      let(:map) { described_class.t(:array_recursion, proc(&:compact)) }
 
       it 'applies funtions to all items recursively' do
         expect(map[input]).to eql(output)
@@ -96,7 +98,7 @@ describe Transproc::Recursion do
     end
 
     context 'when function is destructive' do
-      let(:map) { t(:array_recursion, proc(&:compact!)) }
+      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)
@@ -135,7 +137,9 @@ describe Transproc::Recursion do
     end
 
     context 'when function is non-destructive' do
-      let(:map) { t(:hash_recursion, t(:symbolize_keys)) }
+      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)
@@ -144,7 +148,9 @@ describe Transproc::Recursion do
     end
 
     context 'when function is destructive' do
-      let(:map) { t(:hash_recursion, t(:symbolize_keys!)) }
+      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)

data/spec/unit/registry_spec.rb

@@ -1,95 +1,105 @@
 require 'spec_helper'
 
 describe Transproc::Registry do
-  before do
-    module FooModule
+  before { module Transproc::Test; end         }
+  after  { Transproc.send :remove_const, :Test }
+
+  let(:foo) do
+    Transproc::Test::Foo = Module.new do
       extend Transproc::Registry
 
-      def foo(value, prefix)
-        [prefix, '_', value].join
+      def self.prefix(value, prefix)
+        "#{prefix}_#{value}"
       end
     end
+  end
+  let(:bar) { Transproc::Test::Bar = Module.new { extend Transproc::Registry } }
+  let(:baz) { Transproc::Test::Baz = Module.new { extend Transproc::Registry } }
+
+  describe '.[]' do
+    subject(:transproc) { foo[fn, 'baz'] }
 
-    module BarModule
-      include FooModule
+    context 'from a method' do
+      let(:fn) { :prefix }
 
-      def bar(*args)
-        foo(*args).upcase
+      it 'builds a function from a method' do
+        expect(transproc['qux']).to eql 'baz_qux'
       end
     end
 
-    module BazModule
-      extend Transproc::Registry
+    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 '.[]' do
-    it 'builds function from the method' do
-      fn = ::FooModule[:foo, 'baz']
+  describe '.t' do
+    subject(:transproc) { foo.t(:prefix, 'baz') }
 
-      expect(fn['qux']).to eql 'baz_qux'
+    it 'is an alias for .[]' do
+      expect(transproc['qux']).to eql 'baz_qux'
     end
+  end
 
-    it 'builds function from the proc' do
-      fun = -> value, prefix { [prefix, '_', value].join }
-      fn  = ::FooModule[fun, 'baz']
-
-      expect(fn['qux']).to eql 'baz_qux'
-    end
+  describe '.import' do
+    context 'a module' do
+      subject(:import) { bar.import foo }
 
-    it 'builds function using methods from included modules' do
-      fn = ::BarModule[:bar, 'baz']
+      it 'registers all its methods' do
+        import
+        expect(bar[:prefix, 'baz']['qux']).to eql 'baz_qux'
+      end
 
-      expect(fn['qux']).to eql 'BAZ_QUX'
+      it 'returns itself' do
+        expect(import).to eq bar
+      end
     end
 
-    it 'can access methods from included modules directly' do
-      fn = ::BarModule[:foo, 'baz']
+    context 'a method' do
+      before { bar.import :prefix, from: foo }
 
-      expect(fn['qux']).to eql 'baz_qux'
+      it 'registers a transproc' do
+        expect(bar[:prefix, 'bar']['baz']).to eql 'bar_baz'
+      end
     end
 
-    it 'cannot access undefined methods' do
-      module ::BarModule
-        undef_method :foo
+    context 'an imported method' do
+      before do
+        bar.import :prefix, from: foo, as: :affix
+        baz.import :affix, from: bar
       end
 
-      expect { ::BarModule[:foo, 'baz'] }.to raise_error(NameError)
+      it 'registers a transproc' do
+        expect(baz[:affix, 'bar']['baz']).to eql 'bar_baz'
+      end
     end
-  end
 
-  describe '.uses' do
-    it 'forwards methods to another module directly' do
-      expect { ::BazModule[:baz, 'baz'] }.to raise_error(NameError)
+    context 'a renamed method' do
+      before { bar.import :prefix, from: foo, as: :affix }
 
-      module BazModule
-        uses :foo, as: :ffoo, from: FooModule
-        uses :bar, from: BarModule
+      it 'registers a transproc under the new name' do
+        expect(bar[:affix, 'bar']['baz']).to eql 'bar_baz'
       end
-
-      ffoo = ::BazModule[:ffoo, 'baz']
-      bar  = ::BazModule[:bar, 'baz']
-
-      expect(ffoo['qux']).to eql 'baz_qux'
-      expect(bar['qux']).to eql 'BAZ_QUX'
     end
-  end
 
-  describe '#t' do
-    it 'is an alias for .[]' do
-      module FooModule
-        def qux(value, *args)
-          t(:foo, *args)[value]
+    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 Transproc::FunctionNotFoundError
+          expect(error.message).to include 'Foo[:suffix]'
         end
       end
+    end
+  end
 
-      fn = ::FooModule[:foo, 'baz']
+  describe '.uses' do
+    before { bar.uses foo }
 
-      expect(fn['qux']).to eql 'baz_qux'
+    it 'is an alias for .import' do
+      expect(bar[:prefix, 'baz']['qux']).to eql 'baz_qux'
     end
   end
-
-  after { Object.send :remove_const, :BazModule }
-  after { Object.send :remove_const, :BarModule }
-  after { Object.send :remove_const, :FooModule }
 end

data/spec/unit/store_spec.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+
+describe Transproc::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 'raises KeyError if requested proc is unknown' do
+      expect { store.fetch(:bar) }.to raise_error KeyError
+    end
+  end # describe #fetch
+
+  describe '#import' do
+    before do
+      module Bar
+        def self.bar
+          :bar
+        end
+      end
+
+      module Baz
+        def self.baz
+          :baz
+        end
+      end
+
+      module Qux
+        extend Transproc::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 '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 Transproc::Registry singleton methods' do
+        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 Transproc::Store

data/spec/unit/transproc_spec.rb

@@ -50,6 +50,14 @@ describe Transproc do
     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
+
   describe 'handling malformed input' do
     it 'raises a Transproc::MalformedInputError' do
       expect {

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: transproc
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
 platform: ruby
 authors:
 - Piotr Solnica
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-20 00:00:00.000000000 Z
+date: 2015-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -84,6 +84,9 @@ files:
 - lib/transproc/hash.rb
 - lib/transproc/recursion.rb
 - lib/transproc/registry.rb
+- lib/transproc/rspec.rb
+- lib/transproc/store.rb
+- lib/transproc/support/deprecations.rb
 - lib/transproc/version.rb
 - rakelib/mutant.rake
 - rakelib/rubocop.rake
@@ -94,10 +97,12 @@ files:
 - spec/unit/coercions_spec.rb
 - spec/unit/composer_spec.rb
 - spec/unit/conditional_spec.rb
+- spec/unit/function_not_found_error_spec.rb
 - spec/unit/function_spec.rb
 - spec/unit/hash_transformations_spec.rb
 - spec/unit/recursion_spec.rb
 - spec/unit/registry_spec.rb
+- spec/unit/store_spec.rb
 - spec/unit/transproc_spec.rb
 - transproc.gemspec
 homepage: http://solnic.github.io/transproc/
@@ -132,8 +137,10 @@ test_files:
 - spec/unit/coercions_spec.rb
 - spec/unit/composer_spec.rb
 - spec/unit/conditional_spec.rb
+- spec/unit/function_not_found_error_spec.rb
 - spec/unit/function_spec.rb
 - spec/unit/hash_transformations_spec.rb
 - spec/unit/recursion_spec.rb
 - spec/unit/registry_spec.rb
+- spec/unit/store_spec.rb
 - spec/unit/transproc_spec.rb