functional-ruby 0.7.7 → 1.0.0

data/spec/functional/option_spec.rb

@@ -0,0 +1,292 @@
+require 'spec_helper'
+require_relative 'abstract_struct_shared'
+require 'securerandom'
+
+module Functional
+
+  describe Option do
+
+    let!(:value){ 42 }
+
+    let!(:expected_fields){ [:some] }
+    let!(:expected_values){ [value] }
+
+    let(:struct_class) { Option }
+    let(:struct_object) { Option.some(value) }
+    let(:other_object) { Option.some(Object.new) }
+
+    let(:some_subject){ Option.some(value) }
+    let(:none_subject){ Option.none }
+
+    it_should_behave_like :abstract_struct
+
+    specify{ Functional::Protocol::Satisfy! Option, :Option }
+    specify{ Functional::Protocol::Satisfy! Option, :Disposition }
+
+    let(:some_value){ SecureRandom.uuid }
+    let(:other_value){ SecureRandom.uuid }
+
+    context 'initialization' do
+
+      it 'cannot be constructed directly' do
+        expect {
+          Option.new
+        }.to raise_error(NameError)
+      end
+
+      it 'sets the value when constructed by #some' do
+        expect(Option.some(value).some).to eq value
+      end
+
+      it 'sets the value to nil when constructed by #none' do
+        expect(Option.none.some).to be_nil
+      end
+
+      it 'sets the reason to nil when constructed by #none' do
+        expect(Option.none.reason).to be_nil
+      end
+
+      it 'sets the optional reason when constructed by #none' do
+        reason = 'foobar'
+        expect(Option.none(reason).reason).to eq reason
+      end
+
+      it 'freezes the new object' do
+        expect(Option.some(:foo)).to be_frozen
+        expect(Option.none).to be_frozen
+      end
+    end
+
+    context 'state' do
+
+      specify '#some? returns true when the some value is set' do
+        expect(some_subject).to be_some
+      end
+
+      specify '#some? returns false when none' do
+        expect(none_subject).to_not be_some
+      end
+
+      specify '#none? returns true when none' do
+        expect(none_subject).to be_none
+      end
+
+      specify '#none? returns false when the some value is set' do
+        expect(some_subject).to_not be_none
+      end
+
+      specify '#some returns the some value when some is set' do
+        expect(some_subject.some).to eq value
+      end
+
+      specify '#some returns nil when none is set' do
+        expect(none_subject.some).to be_nil
+      end
+
+      it 'aliases #some? as #fulfilled?' do
+        expect(some_subject).to be_fulfilled
+        expect(none_subject).to_not be_fulfilled
+      end
+
+      it 'aliases #some? as #value?' do
+        expect(some_subject).to be_value
+        expect(none_subject).to_not be_value
+      end
+
+      it 'aliases #none? as #rejected?' do
+        expect(some_subject).to_not be_rejected
+        expect(none_subject).to be_rejected
+      end
+
+      it 'aliases #none? as #reason?' do
+        expect(some_subject).to_not be_reason
+        expect(none_subject).to be_reason
+      end
+
+      it 'aliases #some as #value' do
+        expect(some_subject.value).to eq value
+        expect(none_subject.value).to be_nil
+      end
+
+      specify '#reason returns nil when some' do
+        expect(some_subject.reason).to be_nil
+      end
+    end
+
+    context 'length' do
+
+      it 'returns 1 when some' do
+        expect(Option.some(:foo).length).to eq 1
+      end
+
+      it 'returns 0 when none' do
+        expect(Option.none.length).to eq 0
+      end
+
+      it 'as aliased as #size' do
+        expect(Option.some(:foo).size).to eq 1
+        expect(Option.none.size).to eq 0
+      end
+    end
+
+    context '#and' do
+
+      it 'returns false when none' do
+        expect(Option.none.and(true)).to be false
+      end
+
+      it 'returns true when some and other is a some Option' do
+        other = Option.some(42)
+        expect(Option.some(:foo).and(other)).to be true
+      end
+
+      it 'returns false when some and other is a none Option' do
+        other = Option.none
+        expect(Option.some(:foo).and(other)).to be false
+      end
+
+      it 'passes the value to the given block when some' do
+        expected = false
+        other = ->(some){ expected = some }
+        Option.some(42).and(&other)
+        expect(expected).to eq 42
+      end
+
+      it 'returns true when some and the block returns a truthy value' do
+        other = ->(some){ 'truthy' }
+        expect(Option.some(42).and(&other)).to be true
+      end
+
+      it 'returns false when some and the block returns a falsey value' do
+        other = ->(some){ nil }
+        expect(Option.some(42).and(&other)).to be false
+      end
+
+      it 'returns true when some and given a truthy value' do
+        expect(Option.some(42).and('truthy')).to be true
+      end
+
+      it 'returns false when some and given a falsey value' do
+        expect(Option.some(42).and(nil)).to be false
+      end
+
+      it 'raises an exception when given both a value and a block' do
+        expect {
+          Option.some(42).and(:foo){|some| :bar  }
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#or' do
+
+      it 'returns true when some' do
+        expect(Option.some(42).or(nil)).to be true
+      end
+
+      it 'returns true when none and other is a some Option' do
+        other = Option.some(42)
+        expect(Option.none.or(other)).to be true
+      end
+
+      it 'returns false when none and other is a none Option' do
+        other = Option.none
+        expect(Option.none.or(other)).to be false
+      end
+
+      it 'returns true when none and the block returns a truthy value' do
+        other = ->{ 42 }
+        expect(Option.none.or(&other)).to be true
+      end
+
+      it 'returns false when none and the block returns a falsey value' do
+        other = ->{ false }
+        expect(Option.none.or(&other)).to be false
+      end
+
+      it 'returns true when none and given a truthy value' do
+        expect(Option.none.or('truthy')).to be true
+      end
+
+      it 'returns false when none and given a falsey value' do
+        expect(Option.none.or(nil)).to be false
+      end
+
+      it 'raises an exception when given both a value and a block' do
+        expect {
+          Option.none.and(:foo){ :bar  }
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#else' do
+
+      it 'returns the value when some' do
+        expect(Option.some(some_value).else(other_value)).to eq some_value
+      end
+
+      it 'returns the given value when none' do
+        expect(Option.none.else(other_value)).to eq other_value
+      end
+
+      it 'returns the other value when none and given a some Option' do
+        other = Option.some(other_value)
+        expect(Option.none.else(other)).to eq other_value
+      end
+
+      it 'returns nil when none and given a none Option' do
+        other = Option.none
+        expect(Option.none.else(other)).to be_nil
+      end
+
+      it 'returns the result of the given block when none' do
+        other = ->{ other_value }
+        expect(Option.none.else(&other)).to eq other_value
+      end
+
+      it 'raises an exception when given both a value and a block' do
+        expect {
+          Option.none.else(:foo){ :bar  }
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context '#iff' do
+
+      it 'returns a some option with the given value when the boolean is true' do
+        subject = Option.iff(:foo, true)
+        expect(subject).to be_some
+        expect(subject.some).to eq :foo
+      end
+
+      it 'returns a none option when the boolean is false' do
+        subject = Option.iff(:foo, false)
+        expect(subject).to be_none
+        expect(subject.some).to be_nil
+      end
+
+      it 'returns a some option with the given value when the block is truthy' do
+        subject = Option.iff(:foo){ :baz }
+        expect(subject).to be_some
+        expect(subject.some).to eq :foo
+      end
+
+      it 'returns a none option when the block is false' do
+        subject = Option.iff(:foo){ false }
+        expect(subject).to be_none
+        expect(subject.some).to be_nil
+      end
+
+      it 'returns a none option when the block is nil' do
+        subject = Option.iff(:foo){ nil }
+        expect(subject).to be_none
+        expect(subject.some).to be_nil
+      end
+
+      it 'raises an exception when both a boolean and a block are given' do
+        expect {
+          subject = Option.iff(:foo, true){ nil }
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+end

data/spec/functional/pattern_matching_spec.rb

@@ -1,416 +1,419 @@
 require 'spec_helper'
 require 'ostruct'
 
-describe PatternMatching do
+module Functional
 
-  def new_clazz(&block)
-    clazz = Class.new
-    clazz.send(:include, PatternMatching)
-    clazz.instance_eval(&block) if block_given?
-    return clazz
-  end
+  describe PatternMatching do
 
-  subject { new_clazz }
+    def new_clazz(&block)
+      clazz = Class.new
+      clazz.send(:include, PatternMatching)
+      clazz.instance_eval(&block) if block_given?
+      return clazz
+    end
 
-  context '#defn declaration' do
+    subject { new_clazz }
 
-    it 'can be used within a class declaration' do
-      lambda {
-        class Clazz
-          include PatternMatching
-          defn(:foo){}
-        end
-      }.should_not raise_error
-    end
+    context '#defn declaration' do
 
-    it 'can be used on a class object' do
-      lambda {
-        clazz = Class.new
-        clazz.send(:include, PatternMatching)
-        clazz.defn(:foo){}
-      }.should_not raise_error
-    end
+      it 'can be used within a class declaration' do
+        expect {
+          class Clazz
+            include PatternMatching
+            defn(:foo){}
+          end
+        }.not_to raise_error
+      end
+
+      it 'can be used on a class object' do
+        expect {
+          clazz = Class.new
+          clazz.send(:include, PatternMatching)
+          clazz.defn(:foo){}
+        }.not_to raise_error
+      end
 
-    it 'requires a block' do
-      lambda {
-        clazz = Class.new
-        clazz.send(:include, PatternMatching)
-        clazz.defn(:foo)
-      }.should raise_error(ArgumentError)
+      it 'requires a block' do
+        expect {
+          clazz = Class.new
+          clazz.send(:include, PatternMatching)
+          clazz.defn(:foo)
+        }.to raise_error(ArgumentError)
+      end
     end
-  end
 
-  context 'constructor' do
+    context 'constructor' do
 
-    it 'can pattern match the constructor' do
+      it 'can pattern match the constructor' do
 
-      unless RUBY_VERSION == '1.9.2'
-        subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'three args' }
-        subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'two args' }
-        subject.defn(:initialize, PatternMatching::UNBOUND) { 'one arg' }
+        unless RUBY_VERSION == '1.9.2'
+          subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'three args' }
+          subject.defn(:initialize, PatternMatching::UNBOUND, PatternMatching::UNBOUND) { 'two args' }
+          subject.defn(:initialize, PatternMatching::UNBOUND) { 'one arg' }
 
-        lambda { subject.new(1) }.should_not raise_error
-        lambda { subject.new(1, 2) }.should_not raise_error
-        lambda { subject.new(1, 2, 3) }.should_not raise_error
-        lambda { subject.new(1, 2, 3, 4) }.should raise_error
+          expect { subject.new(1) }.not_to raise_error
+          expect { subject.new(1, 2) }.not_to raise_error
+          expect { subject.new(1, 2, 3) }.not_to raise_error
+          expect { subject.new(1, 2, 3, 4) }.to raise_error
+        end
       end
     end
-  end
 
-  context 'parameter count' do
+    context 'parameter count' do
 
-    it 'does not match a call with not enough arguments' do
+      it 'does not match a call with not enough arguments' do
 
-      subject.defn(:foo, true) { 'expected' }
+        subject.defn(:foo, true) { 'expected' }
 
-      lambda {
-        subject.new.foo()
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo()
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'does not match a call with too many arguments' do
+      it 'does not match a call with too many arguments' do
 
-      subject.defn(:foo, true) { 'expected' }
+        subject.defn(:foo, true) { 'expected' }
+
+        expect {
+          subject.new.foo(true, false)
+        }.to raise_error(NoMethodError)
+      end
 
-      lambda {
-        subject.new.foo(true, false)
-      }.should raise_error(NoMethodError)
     end
 
-  end
+    context 'recursion' do
 
-  context 'recursion' do
+      it 'defers unmatched calls to the superclass' do
 
-    it 'defers unmatched calls to the superclass' do
+        class UnmatchedCallTesterSuperclass
+          def foo(bar)
+            return bar
+          end
+        end
 
-      class UnmatchedCallTesterSuperclass
-        def foo(bar)
-          return bar
+        class UnmatchedCallTesterSubclass < UnmatchedCallTesterSuperclass
+          include PatternMatching
+          defn(:foo) { 'baz' }
         end
-      end
 
-      class UnmatchedCallTesterSubclass < UnmatchedCallTesterSuperclass
-        include PatternMatching
-        defn(:foo) { 'baz' }
+        subject = UnmatchedCallTesterSubclass.new
+        expect(subject.foo(:bar)).to eq :bar
       end
 
-      subject = UnmatchedCallTesterSubclass.new
-      subject.foo(:bar).should eq :bar
-    end
+      it 'can call another match from within a match' do
 
-    it 'can call another match from within a match' do
+        subject.defn(:foo, :bar) { |arg| foo(:baz) }
+        subject.defn(:foo, :baz) { |arg| 'expected' }
 
-      subject.defn(:foo, :bar) { |arg| foo(:baz) }
-      subject.defn(:foo, :baz) { |arg| 'expected' }
+        expect(subject.new.foo(:bar)).to eq 'expected'
+      end
 
-      subject.new.foo(:bar).should eq 'expected'
-    end
+      it 'can call a superclass method from within a match' do
 
-    it 'can call a superclass method from within a match' do
+        class RecursiveCallTesterSuperclass
+          def foo(bar)
+            return bar
+          end
+        end
 
-      class RecursiveCallTesterSuperclass
-        def foo(bar)
-          return bar
+        class RecursiveCallTesterSubclass < RecursiveCallTesterSuperclass
+          include PatternMatching
+          defn(:foo, :bar) { foo(:baz) }
         end
-      end
 
-      class RecursiveCallTesterSubclass < RecursiveCallTesterSuperclass
-        include PatternMatching
-        defn(:foo, :bar) { foo(:baz) }
+        subject = RecursiveCallTesterSubclass.new
+        expect(subject.foo(:bar)).to eq :baz
       end
-
-      subject = RecursiveCallTesterSubclass.new
-      subject.foo(:bar).should eq :baz
     end
-  end
 
-  context 'datatypes' do
+    context 'datatypes' do
 
-    it 'matches an argument of the class given in the match parameter' do
+      it 'matches an argument of the class given in the match parameter' do
 
-      subject.defn(:foo, Integer) { 'expected' }
-      subject.new.foo(100).should eq 'expected'
+        subject.defn(:foo, Integer) { 'expected' }
+        expect(subject.new.foo(100)).to eq 'expected'
 
-      lambda {
-        subject.new.foo('hello')
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo('hello')
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'passes the matched argument to the block' do
+      it 'passes the matched argument to the block' do
 
-      subject.defn(:foo, Integer) { |arg| arg }
-      subject.new.foo(100).should eq 100
+        subject.defn(:foo, Integer) { |arg| arg }
+        expect(subject.new.foo(100)).to eq 100
+      end
     end
-  end
 
-  context 'function with no parameters' do
+    context 'function with no parameters' do
 
-    it 'accepts no parameters' do
+      it 'accepts no parameters' do
 
-      subject.defn(:foo){}
-      obj = subject.new
+        subject.defn(:foo){}
+        obj = subject.new
 
-      lambda {
-        obj.foo
-      }.should_not raise_error
-    end
+        expect {
+          obj.foo
+        }.not_to raise_error
+      end
 
-    it 'does not accept any parameters' do
+      it 'does not accept any parameters' do
 
-      subject.defn(:foo){}
-      obj = subject.new
+        subject.defn(:foo){}
+        obj = subject.new
 
-      lambda {
-        obj.foo(1)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          obj.foo(1)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'returns the correct value' do
-      subject.defn(:foo){ true }
-      subject.new.foo.should be_true
+      it 'returns the correct value' do
+        subject.defn(:foo){ true }
+        expect(subject.new.foo).to be true
+      end
     end
-  end
 
-  context 'function with one parameter' do
+    context 'function with one parameter' do
 
-    it 'matches a nil parameter' do
+      it 'matches a nil parameter' do
 
-      subject.defn(:foo, nil) { 'expected' }
-      subject.new.foo(nil).should eq 'expected'
+        subject.defn(:foo, nil) { 'expected' }
+        expect(subject.new.foo(nil)).to eq 'expected'
 
-      lambda {
-        subject.new.foo('no match should be found')
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo('no match should be found')
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches a boolean parameter' do
+      it 'matches a boolean parameter' do
 
-      subject.defn(:foo, true) { 'expected' }
-      subject.defn(:foo, false) { 'false case' }
+        subject.defn(:foo, true) { 'expected' }
+        subject.defn(:foo, false) { 'false case' }
 
-      subject.new.foo(true).should eq 'expected'
-      subject.new.foo(false).should eq 'false case'
+        expect(subject.new.foo(true)).to eq 'expected'
+        expect(subject.new.foo(false)).to eq 'false case'
 
-      lambda {
-        subject.new.foo('no match should be found')
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo('no match should be found')
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches a symbol parameter' do
+      it 'matches a symbol parameter' do
 
-      subject.defn(:foo, :bar) { 'expected' }
-      subject.new.foo(:bar).should eq 'expected'
+        subject.defn(:foo, :bar) { 'expected' }
+        expect(subject.new.foo(:bar)).to eq 'expected'
 
-      lambda {
-        subject.new.foo(:baz)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(:baz)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches a number parameter' do
+      it 'matches a number parameter' do
 
-      subject.defn(:foo, 10) { 'expected' }
-      subject.new.foo(10).should eq 'expected'
+        subject.defn(:foo, 10) { 'expected' }
+        expect(subject.new.foo(10)).to eq 'expected'
 
-      lambda {
-        subject.new.foo(11.0)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(11.0)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches a string parameter' do
+      it 'matches a string parameter' do
 
-      subject.defn(:foo, 'bar') { 'expected' }
-      subject.new.foo('bar').should eq 'expected'
+        subject.defn(:foo, 'bar') { 'expected' }
+        expect(subject.new.foo('bar')).to eq 'expected'
 
-      lambda {
-        subject.new.foo('baz')
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo('baz')
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches an array parameter' do
+      it 'matches an array parameter' do
 
-      subject.defn(:foo, [1, 2, 3]) { 'expected' }
-      subject.new.foo([1, 2, 3]).should eq 'expected'
+        subject.defn(:foo, [1, 2, 3]) { 'expected' }
+        expect(subject.new.foo([1, 2, 3])).to eq 'expected'
 
-      lambda {
-        subject.new.foo([3, 4, 5])
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo([3, 4, 5])
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches a hash parameter' do
+      it 'matches a hash parameter' do
 
-      subject.defn(:foo, bar: 1, baz: 2) { 'expected' }
-      subject.new.foo(bar: 1, baz: 2).should eq 'expected'
+        subject.defn(:foo, bar: 1, baz: 2) { 'expected' }
+        expect(subject.new.foo(bar: 1, baz: 2)).to eq 'expected'
 
-      lambda {
-        subject.new.foo(foo: 0, bar: 1)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(foo: 0, bar: 1)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches an object parameter' do
+      it 'matches an object parameter' do
 
-      subject.defn(:foo, OpenStruct.new(foo: :bar)) { 'expected' }
-      subject.new.foo(OpenStruct.new(foo: :bar)).should eq 'expected'
+        subject.defn(:foo, OpenStruct.new(foo: :bar)) { 'expected' }
+        expect(subject.new.foo(OpenStruct.new(foo: :bar))).to eq 'expected'
 
-      lambda {
-        subject.new.foo(OpenStruct.new(bar: :baz))
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(OpenStruct.new(bar: :baz))
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches an unbound parameter' do
+      it 'matches an unbound parameter' do
 
-      subject.defn(:foo, PatternMatching::UNBOUND) {|arg| arg }
-      subject.new.foo(:foo).should eq :foo
+        subject.defn(:foo, PatternMatching::UNBOUND) {|arg| arg }
+        expect(subject.new.foo(:foo)).to eq :foo
+      end
     end
-  end
 
-  context 'function with two parameters' do
+    context 'function with two parameters' do
 
-    it 'matches two bound arguments' do
+      it 'matches two bound arguments' do
 
-      subject.defn(:foo, :male, :female){ 'expected' }
-      subject.new.foo(:male, :female).should eq 'expected'
+        subject.defn(:foo, :male, :female){ 'expected' }
+        expect(subject.new.foo(:male, :female)).to eq 'expected'
 
-      lambda {
-        subject.new.foo(1, 2)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(1, 2)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches two unbound arguments' do
+      it 'matches two unbound arguments' do
 
-      subject.defn(:foo, PatternMatching::UNBOUND, PatternMatching::UNBOUND) do |first, second|
-        [first, second]
+        subject.defn(:foo, PatternMatching::UNBOUND, PatternMatching::UNBOUND) do |first, second|
+          [first, second]
+        end
+        expect(subject.new.foo(:male, :female)).to eq [:male, :female]
       end
-      subject.new.foo(:male, :female).should eq [:male, :female]
-    end
 
-    it 'matches when the first argument is bound and the second is not' do
+      it 'matches when the first argument is bound and the second is not' do
 
-      subject.defn(:foo, :male, PatternMatching::UNBOUND) do |second|
-        second
+        subject.defn(:foo, :male, PatternMatching::UNBOUND) do |second|
+          second
+        end
+        expect(subject.new.foo(:male, :female)).to eq :female
       end
-      subject.new.foo(:male, :female).should eq :female
-    end
 
-    it 'matches when the second argument is bound and the first is not' do
+      it 'matches when the second argument is bound and the first is not' do
 
-      subject.defn(:foo, PatternMatching::UNBOUND, :female) do |first|
-        first
+        subject.defn(:foo, PatternMatching::UNBOUND, :female) do |first|
+          first
+        end
+        expect(subject.new.foo(:male, :female)).to eq :male
       end
-      subject.new.foo(:male, :female).should eq :male
     end
-  end
 
-  context 'functions with hash arguments' do
+    context 'functions with hash arguments' do
 
-    it 'matches an empty argument hash with an empty parameter hash' do
+      it 'matches an empty argument hash with an empty parameter hash' do
 
-      subject.defn(:foo, {}) { true }
-      subject.new.foo({}).should be_true
+        subject.defn(:foo, {}) { true }
+        expect(subject.new.foo({})).to be true
 
-      lambda {
-        subject.new.foo({one: :two})
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo({one: :two})
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches when all hash keys and values match' do
+      it 'matches when all hash keys and values match' do
 
-      subject.defn(:foo, {bar: :baz}) { true }
-      subject.new.foo(bar: :baz).should be_true
+        subject.defn(:foo, {bar: :baz}) { true }
+        expect(subject.new.foo(bar: :baz)).to be true
 
-      lambda {
-        subject.new.foo({one: :two})
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo({one: :two})
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'matches when every pattern key/value are in the argument' do
+      it 'matches when every pattern key/value are in the argument' do
 
-      subject.defn(:foo, {bar: :baz}) { true }
-      subject.new.foo(foo: :bar, bar: :baz).should be_true
-    end
+        subject.defn(:foo, {bar: :baz}) { true }
+        expect(subject.new.foo(foo: :bar, bar: :baz)).to be true
+      end
 
-    it 'matches when all keys with unbound values in the pattern have an argument' do
+      it 'matches when all keys with unbound values in the pattern have an argument' do
 
-      subject.defn(:foo, {bar: PatternMatching::UNBOUND}) { true }
-      subject.new.foo(bar: :baz).should be_true
-    end
+        subject.defn(:foo, {bar: PatternMatching::UNBOUND}) { true }
+        expect(subject.new.foo(bar: :baz)).to be true
+      end
 
-    it 'passes unbound values to the block' do
+      it 'passes unbound values to the block' do
 
-      subject.defn(:foo, {bar: PatternMatching::UNBOUND}) {|arg| arg }
-      subject.new.foo(bar: :baz).should eq :baz
-    end
+        subject.defn(:foo, {bar: PatternMatching::UNBOUND}) {|arg| arg }
+        expect(subject.new.foo(bar: :baz)).to eq :baz
+      end
 
-    it 'passes the matched hash to the block' do
+      it 'passes the matched hash to the block' do
 
-      subject.defn(:foo, {bar: :baz}) { |opts| opts }
-      subject.new.foo(bar: :baz).should == {bar: :baz}
-    end
+        subject.defn(:foo, {bar: :baz}) { |opts| opts }
+        expect(subject.new.foo(bar: :baz)).to eq({bar: :baz})
+      end
 
-    it 'does not match a non-hash argument' do
+      it 'does not match a non-hash argument' do
 
-      subject.defn(:foo, {}) { true }
+        subject.defn(:foo, {}) { true }
 
-      lambda {
-        subject.new.foo(:bar)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.foo(:bar)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'supports idiomatic has-as-last-argument syntax' do
+      it 'supports idiomatic has-as-last-argument syntax' do
 
-      subject.defn(:foo, PatternMatching::UNBOUND) { |opts| opts }
-      subject.new.foo(bar: :baz, one: 1, many: 2).should == {bar: :baz, one: 1, many: 2}
+        subject.defn(:foo, PatternMatching::UNBOUND) { |opts| opts }
+        expect(subject.new.foo(bar: :baz, one: 1, many: 2)).to eq({bar: :baz, one: 1, many: 2})
+      end
     end
-  end
 
-  context 'varaible-length argument lists' do
+    context 'varaible-length argument lists' do
+
+      it 'supports ALL as the last parameter' do
 
-    it 'supports ALL as the last parameter' do
-      
-      subject.defn(:foo, 1, 2, PatternMatching::ALL) { |args| args }
-      subject.new.foo(1, 2, 3).should == [3]
-      subject.new.foo(1, 2, :foo, :bar).should == [:foo, :bar]
-      subject.new.foo(1, 2, :foo, :bar, one: 1, two: 2).should == [:foo, :bar, {one: 1, two: 2}]
+        subject.defn(:foo, 1, 2, PatternMatching::ALL) { |args| args }
+        expect(subject.new.foo(1, 2, 3)).to eq([3])
+        expect(subject.new.foo(1, 2, :foo, :bar)).to eq([:foo, :bar])
+        expect(subject.new.foo(1, 2, :foo, :bar, one: 1, two: 2)).to eq([:foo, :bar, {one: 1, two: 2}])
+      end
     end
-  end
 
-  context 'guard clauses' do
+    context 'guard clauses' do
 
-    it 'matches when the guard clause returns true' do
+      it 'matches when the guard clause returns true' do
 
-      subject.defn(:old_enough, PatternMatching::UNBOUND){
-        true
-      }.when{|x| x > 16 }
+        subject.defn(:old_enough, PatternMatching::UNBOUND){
+          true
+        }.when{|x| x > 16 }
 
-      subject.new.old_enough(20).should be_true
-    end
+        expect(subject.new.old_enough(20)).to be true
+      end
 
-    it 'does not match when the guard clause returns false' do
+      it 'does not match when the guard clause returns false' do
 
-      subject.defn(:old_enough, PatternMatching::UNBOUND){
-        true
-      }.when{|x| x > 16 }
+        subject.defn(:old_enough, PatternMatching::UNBOUND){
+          true
+        }.when{|x| x > 16 }
 
-      lambda {
-        subject.new.old_enough(10)
-      }.should raise_error(NoMethodError)
-    end
+        expect {
+          subject.new.old_enough(10)
+        }.to raise_error(NoMethodError)
+      end
 
-    it 'continues pattern matching when the guard clause returns false' do
+      it 'continues pattern matching when the guard clause returns false' do
 
-      subject.defn(:old_enough, PatternMatching::UNBOUND){
-        true
-      }.when{|x| x > 16 }
+        subject.defn(:old_enough, PatternMatching::UNBOUND){
+          true
+        }.when{|x| x > 16 }
 
-      subject.defn(:old_enough, PatternMatching::UNBOUND) { false }
+        subject.defn(:old_enough, PatternMatching::UNBOUND) { false }
 
-      subject.new.old_enough(10).should be_false
-    end
+        expect(subject.new.old_enough(10)).to be false
+      end
 
-    it 'raises an exception when the guard clause does not have a block' do
+      it 'raises an exception when the guard clause does not have a block' do
 
-      lambda {
-        subject.defn(:foo).when
-      }.should raise_error(ArgumentError)
+        expect {
+          subject.defn(:initialize, PatternMatching::UNBOUND) { 'one arg' }.when
+        }.to raise_error(ArgumentError)
+      end
     end
   end
 end