functional-ruby 0.7.7 → 1.0.0

data/spec/functional/configuration_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module Functional
+
+  context Configuration do
+
+    it 'configures the gem' do
+      cfg = nil
+      Functional.configure do |config|
+        cfg = config
+      end
+
+      expect(cfg).to be_a Configuration
+      expect(cfg).to eq Functional.configuration
+    end
+  end
+end

data/spec/functional/delay_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+module Functional
+
+  describe Delay do
+
+    let!(:fulfilled_value) { 10 }
+    let!(:rejected_reason) { StandardError.new('mojo jojo') }
+
+    let(:pending_subject) do
+      Delay.new{ fulfilled_value }
+    end
+
+    let(:fulfilled_subject) do
+      delay = Delay.new{ fulfilled_value }
+      delay.tap{ delay.value }
+    end
+
+    let(:rejected_subject) do
+      delay = Delay.new{ raise rejected_reason }
+      delay.tap{ delay.value }
+    end
+
+    specify{ Functional::Protocol::Satisfy! Delay, :Disposition }
+
+    context '#initialize' do
+
+      it 'sets the state to :pending' do
+        expect(Delay.new{ nil }.state).to eq :pending
+        expect(Delay.new{ nil }).to be_pending
+      end
+
+      it 'raises an exception when no block given' do
+        expect {
+          Delay.new
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#state' do
+
+      it 'is :pending when first created' do
+        f = pending_subject
+        expect(f.state).to eq(:pending)
+        expect(f).to be_pending
+      end
+
+      it 'is :fulfilled when the handler completes' do
+        f = fulfilled_subject
+        expect(f.state).to eq(:fulfilled)
+        expect(f).to be_fulfilled
+      end
+
+      it 'is :rejected when the handler raises an exception' do
+        f = rejected_subject
+        expect(f.state).to eq(:rejected)
+        expect(f).to be_rejected
+      end
+    end
+
+    context '#value' do
+
+      let(:task){ proc{ nil } }
+
+      it 'blocks the caller when :pending and timeout is nil' do
+        f = pending_subject
+        expect(f.value).to be_truthy
+        expect(f).to be_fulfilled
+      end
+
+      it 'is nil when :rejected' do
+        expected = rejected_subject.value
+        expect(expected).to be_nil
+      end
+
+      it 'is set to the return value of the block when :fulfilled' do
+        expected = fulfilled_subject.value
+        expect(expected).to eq fulfilled_value
+      end
+
+      it 'does not call the block before #value is called' do
+        expect(task).not_to receive(:call).with(any_args)
+        Delay.new(&task)
+      end
+
+      it 'calls the block when #value is called' do
+        expect(task).to receive(:call).once.with(any_args).and_return(nil)
+        Delay.new(&task).value
+      end
+
+      it 'only calls the block once no matter how often #value is called' do
+        expect(task).to receive(:call).once.with(any_args).and_return(nil)
+        delay = Delay.new(&task)
+        5.times{ delay.value }
+      end
+    end
+
+    context '#reason' do
+
+      it 'is nil when :pending' do
+        expect(pending_subject.reason).to be_nil
+      end
+
+      it 'is nil when :fulfilled' do
+        expect(fulfilled_subject.reason).to be_nil
+      end
+
+      it 'is set to error object of the exception when :rejected' do
+        expect(rejected_subject.reason).to be_a(Exception)
+        expect(rejected_subject.reason.to_s).to match(/#{rejected_reason}/)
+      end
+    end
+
+    context 'predicates' do
+
+      specify '#value? returns true when :fulfilled' do
+        expect(pending_subject).to_not be_value
+        expect(fulfilled_subject).to be_value
+        expect(rejected_subject).to_not be_value
+      end
+
+      specify '#reason? returns true when :rejected' do
+        expect(pending_subject).to_not be_reason
+        expect(fulfilled_subject).to_not be_reason
+        expect(rejected_subject).to be_reason
+      end
+
+      specify '#fulfilled? returns true when :fulfilled' do
+        expect(pending_subject).to_not be_fulfilled
+        expect(fulfilled_subject).to be_fulfilled
+        expect(rejected_subject).to_not be_fulfilled
+      end
+
+      specify '#rejected? returns true when :rejected' do
+        expect(pending_subject).to_not be_rejected
+        expect(fulfilled_subject).to_not be_rejected
+        expect(rejected_subject).to be_rejected
+      end
+
+      specify '#pending? returns true when :pending' do
+        expect(pending_subject).to be_pending
+        expect(fulfilled_subject).to_not be_pending
+        expect(rejected_subject).to_not be_pending
+      end
+    end
+  end
+end

data/spec/functional/either_spec.rb

@@ -0,0 +1,237 @@
+require 'spec_helper'
+require_relative 'abstract_struct_shared'
+
+module Functional
+
+  describe Either do
+
+    let!(:value){ 42 }
+    let!(:reason){ StandardError.new }
+
+    let!(:expected_fields){ [:left, :right] }
+    let!(:expected_values){ [value, nil] }
+
+    let(:struct_class) { Either }
+    let(:struct_object) { Either.left(value) }
+    let(:other_object) { Either.left(Object.new) }
+
+    let(:left_subject){ Either.left(reason) }
+    let(:right_subject){ Either.right(value) }
+
+    it_should_behave_like :abstract_struct
+
+    specify{ Functional::Protocol::Satisfy! Either, :Either }
+    specify{ Functional::Protocol::Satisfy! Either, :Disposition }
+
+    context 'initialization' do
+
+      it 'cannot be constructed directly' do
+        expect {
+          Either.new
+        }.to raise_error(NameError)
+      end
+
+      it 'sets the left value when constructed by #left' do
+        expect(Either.left(value).left).to eq value
+      end
+
+      it 'sets the right value when constructed by #right' do
+        expect(Either.right(value).right).to eq value
+      end
+
+      it 'freezes the new object' do
+        expect(Either.left(:foo)).to be_frozen
+        expect(Either.right(:foo)).to be_frozen
+      end
+
+      it 'aliases #left to #reason' do
+        expect(Either.reason(value).left).to eq value
+      end
+
+      it 'aliases #right to #value' do
+        expect(Either.value(value).right).to eq value
+      end
+
+      context '#error' do
+
+        it 'sets left to a StandardError with backtrace when no arguments given' do
+          either = Either.error
+          expect(either.left).to be_a StandardError
+          expect(either.left.message).to_not be nil
+          expect(either.left.backtrace).to_not be_empty
+        end
+
+        it 'sets left to a StandardError with the given message' do
+          message = 'custom error message'
+          either = Either.error(message)
+          expect(either.left).to be_a StandardError
+          expect(either.left.message).to eq message
+          expect(either.left.backtrace).to_not be_empty
+        end
+
+        it 'sets left to an object of the given class with the given message' do
+          message = 'custom error message'
+          error_class = ArgumentError
+          either = Either.error(message, error_class)
+          expect(either.left).to be_a error_class
+          expect(either.left.message).to eq message
+          expect(either.left.backtrace).to_not be_empty
+        end
+      end
+    end
+
+    context 'state' do
+
+      specify '#left? returns true when the left value is set' do
+        expect(left_subject).to be_left
+      end
+
+      specify '#left? returns false when the right value is set' do
+        expect(right_subject).to_not be_left
+      end
+
+      specify '#right? returns true when the right value is set' do
+        expect(right_subject).to be_right
+      end
+
+      specify '#right? returns false when the left value is set' do
+        expect(left_subject).to_not be_right
+      end
+
+      specify '#left returns the left value when left is set' do
+        expect(left_subject.left).to eq reason
+      end
+
+      specify '#left returns nil when right is set' do
+        expect(right_subject.left).to be_nil
+      end
+
+      specify '#right returns the right value when right is set' do
+        expect(right_subject.right).to eq value
+      end
+
+      specify '#right returns nil when left is set' do
+        expect(left_subject.right).to be_nil
+      end
+
+      specify 'aliases #left? as #reason?' do
+        expect(left_subject.reason?).to be true
+      end
+
+      specify 'aliases #right? as #value?' do
+        expect(right_subject.value?).to be true
+      end
+
+      specify 'aliases #left as #reason' do
+        expect(left_subject.reason).to eq reason
+        expect(right_subject.reason).to be_nil
+      end
+
+      specify 'aliases #right as #value' do
+        expect(right_subject.value).to eq value
+        expect(left_subject.value).to be_nil
+      end
+    end
+
+    context '#swap' do
+
+      it 'converts a left projection into a right projection' do
+        subject = Either.left(:foo)
+        swapped = subject.swap
+        expect(swapped).to be_right
+        expect(swapped.left).to be_nil
+        expect(swapped.right).to eq :foo
+      end
+
+      it 'converts a right projection into a left projection' do
+        subject = Either.right(:foo)
+        swapped = subject.swap
+        expect(swapped).to be_left
+        expect(swapped.right).to be_nil
+        expect(swapped.left).to eq :foo
+      end
+    end
+
+    context '#either' do
+
+      it 'passes the left value to the left proc when left' do
+        expected = nil
+        subject = Either.left(100)
+        subject.either(
+          ->(left) { expected = left },
+          ->(right) { expected = -1 }
+        )
+        expect(expected).to eq 100
+      end
+
+      it 'returns the value of the left proc when left' do
+        subject = Either.left(100)
+        expect(
+          subject.either(
+            ->(left) { left * 2 },
+            ->(right) { nil }
+          )
+        ).to eq 200
+      end
+
+      it 'passes the right value to the right proc when right' do
+        expected = nil
+        subject = Either.right(100)
+        subject.either(
+          ->(right) { expected = -1 },
+          ->(right) { expected = right }
+        )
+        expect(expected).to eq 100
+      end
+
+      it 'returns the value of the right proc when right' do
+        subject = Either.right(100)
+        expect(
+          subject.either(
+            ->(right) { nil },
+            ->(right) { right * 2 }
+          )
+        ).to eq 200
+      end
+    end
+
+    context '#iff' do
+
+      it 'returns a lefty with the given left value when the boolean is true' do
+        subject = Either.iff(:foo, :bar, true)
+        expect(subject).to be_left
+        expect(subject.left).to eq :foo
+      end
+
+      it 'returns a righty with the given right value when the boolean is false' do
+        subject = Either.iff(:foo, :bar, false)
+        expect(subject).to be_right
+        expect(subject.right).to eq :bar
+      end
+
+      it 'returns a lefty with the given left value when the block is truthy' do
+        subject = Either.iff(:foo, :bar){ :baz }
+        expect(subject).to be_left
+        expect(subject.left).to eq :foo
+      end
+
+      it 'returns a righty with the given right value when the block is false' do
+        subject = Either.iff(:foo, :bar){ false }
+        expect(subject).to be_right
+        expect(subject.right).to eq :bar
+      end
+
+      it 'returns a righty with the given right value when the block is nil' do
+        subject = Either.iff(:foo, :bar){ nil }
+        expect(subject).to be_right
+        expect(subject.right).to eq :bar
+      end
+
+      it 'raises an exception when both a boolean and a block are given' do
+        expect {
+          subject = Either.iff(:foo, :bar, true){ nil }
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/functional/memo_spec.rb

@@ -0,0 +1,207 @@
+require 'spec_helper'
+
+module Functional
+
+  describe Memo do
+
+    def create_new_memo_class
+      Class.new do
+        include Functional::Memo
+
+        class << self
+          attr_accessor :count
+        end
+
+        self.count = 0
+
+        def self.add(a, b)
+          self.count += 1
+          a + b
+        end
+        memoize :add
+
+        def self.increment(n)
+          self.count += 1
+        end
+
+        def self.exception(ex = StandardError)
+          raise ex
+        end
+      end
+    end
+
+    subject{ create_new_memo_class }
+
+    context 'specification' do
+
+      it 'raises an exception when the method is not defined' do
+        expect {
+          subject.memoize(:bogus)
+        }.to raise_error(NameError)
+      end
+
+      it 'raises an exception when the given method has already been memoized' do
+        expect{
+          subject.memoize(:add)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'allocates a different cache for each class/module' do
+        class_1 = create_new_memo_class
+        class_2 = create_new_memo_class
+
+        10.times do
+          class_1.add(0, 0)
+          class_2.add(0, 0)
+        end
+
+        expect(class_1.count).to eq 1
+        expect(class_2.count).to eq 1
+      end
+
+      it 'works when included in a class' do
+        subject = Class.new do
+          include Functional::Memo
+          class << self
+            attr_accessor :count
+          end
+          self.count = 0
+          def self.foo
+            self.count += 1
+          end
+          memoize :foo
+        end
+
+        10.times{ subject.foo }
+        expect(subject.count).to eq 1
+      end
+
+      it 'works when included in a module' do
+        subject = Module.new do
+          include Functional::Memo
+          class << self
+            attr_accessor :count
+          end
+          self.count = 0
+          def self.foo
+            self.count += 1
+          end
+          memoize :foo
+        end
+
+        10.times{ subject.foo }
+        expect(subject.count).to eq 1
+      end
+
+      it 'works when extended by a module' do
+        subject = Module.new do
+          extend Functional::Memo
+          class << self
+            attr_accessor :count
+          end
+          self.count = 0
+          def self.foo
+            self.count += 1
+          end
+          memoize :foo
+        end
+
+        10.times{ subject.foo }
+        expect(subject.count).to eq 1
+      end
+    end
+
+    context 'caching behavior' do
+
+      it 'calls the real method on first instance of given args' do
+        subject.add(1, 2)
+        expect(subject.count).to eq 1
+      end
+
+      it 'calls the real method on first instance of given args' do
+        subject.add(1, 2)
+        expect(subject.count).to eq 1
+      end
+
+      it 'uses the memo on second instance of given args' do
+        5.times { subject.add(1, 2) }
+        expect(subject.count).to eq 1
+      end
+
+      it 'calls the real method when given a block' do
+        5.times { subject.add(1, 2){ nil } }
+        expect(subject.count).to eq 5
+      end
+
+      it 'raises an exception when arity does not match' do
+        expect {
+          subject.add
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'maximum cache size' do
+
+      it 'raises an exception when given a non-positive :at_most' do
+        expect {
+          subject.memoize(:increment, at_most: -1)
+        }.to raise_error(ArgumentError)
+      end
+
+      it 'sets no limit when :at_most not given' do
+        subject.memoize(:increment)
+        10000.times{|i| subject.increment(i) }
+        expect(subject.count).to eq 10000
+      end
+
+      it 'calls the real method when the :at_most size is reached' do
+        subject.memoize(:increment, at_most: 5)
+        10000.times{|i| subject.increment(i % 10) }
+        expect(subject.count).to eq 5005
+      end
+    end
+
+    context 'thread safety' do
+
+      let(:mutex){ Mutex.new }
+
+      before(:each) do
+        allow(Mutex).to receive(:new).with(no_args).and_return(mutex)
+        allow(mutex).to receive(:lock).with(no_args).and_return(mutex)
+        allow(mutex).to receive(:unlock).with(no_args).and_return(mutex)
+      end
+
+      it 'locks a mutex whenever a memoized function is called' do
+        expect(mutex).to receive(:lock).exactly(:once).with(no_args)
+
+        subject.memoize(:increment)
+        subject.increment(0)
+      end
+
+      it 'unlocks the mutex whenever a memoized function is called' do
+        expect(mutex).to receive(:unlock).exactly(:once).with(no_args)
+
+        subject.memoize(:increment)
+        subject.increment(0)
+      end
+
+      it 'unlocks the mutex when the method call raises an exception' do
+        expect(mutex).to receive(:unlock).exactly(:once).with(no_args)
+
+        subject.memoize(:exception)
+        begin
+          subject.exception
+        rescue
+          # suppress
+        end
+      end
+
+      it 'uses different mutexes for different functions' do
+        expect(Mutex).to receive(:new).with(no_args).exactly(3).times.and_return(mutex)
+        # once for memoize(:add) in the definition
+        subject.memoize(:increment)
+        subject.memoize(:exception)
+      end
+    end
+  end
+end