functional-ruby 0.5.0

data/spec/functional/integration_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+require 'ostruct'
+
+  class Bar
+    def greet
+      return 'Hello, World!'
+    end
+  end
+
+  class Foo < Bar
+    include PatternMatching
+
+    attr_accessor :name
+
+    defn(:initialize) { @name = 'baz' }
+    defn(:initialize, _) {|name| @name = name.to_s }
+
+    defn(:greet, _) do |name|
+      "Hello, #{name}!"
+    end
+
+    defn(:greet, :male, _) { |name|
+      "Hello, Mr. #{name}!"
+    }
+    defn(:greet, :female, _) { |name|
+      "Hello, Ms. #{name}!"
+    }
+    defn(:greet, nil, _) { |name|
+      "Goodbye, #{name}!"
+    }
+    defn(:greet, _, _) { |_, name|
+      "Hello, #{name}!"
+    }
+
+    defn(:hashable, _, {foo: :bar}, _) { |_, opts, _|
+      :foo_bar
+    }
+    defn(:hashable, _, {foo: _, bar: _}, _) { |_, f, b, _|
+      [f, b]
+    }
+    defn(:hashable, _, {foo: _}, _) { |_, f, _|
+      f
+    }
+    defn(:hashable, _, {}, _) {
+      :empty
+    }
+    defn(:hashable, _, _, _) { |_, _, _|
+      :unbound
+    }
+
+    defn(:options, _) { |opts|
+      opts
+    }
+
+    defn(:recurse) {
+      'w00t!'
+    }
+    defn(:recurse, :match) {
+      recurse()
+    }
+    defn(:recurse, :super) {
+      greet()
+    }
+    defn(:recurse, :instance) {
+      @name
+    }
+    defn(:recurse, _) { |arg|
+      arg
+    }
+
+    defn(:concat, Integer, Integer) { |first, second|
+      first + second
+    }
+    defn(:concat, Integer, String) { |first, second|
+      "#{first} #{second}"
+    }
+    defn(:concat, String, String) { |first, second|
+      first + second
+    }
+    defn(:concat, Integer, UNBOUND) { |first, second|
+      first + second.to_i
+    }
+
+    defn(:all, :one, ALL) { |args|
+      args
+    }
+    defn(:all, :one, Integer, ALL) { |int, args|
+      [int, args]
+    }
+    defn(:all, 1, _, ALL) { |var, args|
+      [var, args]
+    }
+    defn(:all, ALL) { | args|
+      args
+    }
+
+    defn(:old_enough, _){ true }.when{|x| x >= 16 }
+    defn(:old_enough, _){ false }
+
+    defn(:right_age, _) {
+      true
+    }.when{|x| x >= 16 && x <= 104 }
+
+    defn(:right_age, _) {
+      false
+    }
+
+    defn(:wrong_age, _) {
+      true
+    }.when{|x| x < 16 || x > 104 }
+
+    defn(:wrong_age, _) {
+      false
+    }
+  end
+
+  class Baz < Foo
+    def boom_boom_room
+      'zoom zoom zoom'
+    end
+    def who(first, last)
+      [first, last].join(' ')
+    end
+  end
+
+  class Fizzbuzz < Baz
+    include PatternMatching
+    defn(:who, Integer) { |count|
+      (1..count).each.reduce(:+)
+    }
+    defn(:who) { 0 }
+  end
+
+describe 'integration' do
+
+  let(:name) { 'Pattern Matcher' }
+  subject { Foo.new(name) }
+
+  specify { subject.greet.should eq 'Hello, World!' }
+
+  specify { subject.greet('Jerry').should eq 'Hello, Jerry!' }
+
+  specify { subject.greet(:male, 'Jerry').should eq 'Hello, Mr. Jerry!' }
+  specify { subject.greet(:female, 'Jeri').should eq 'Hello, Ms. Jeri!' }
+  specify { subject.greet(:unknown, 'Jerry').should eq 'Hello, Jerry!' }
+  specify { subject.greet(nil, 'Jerry').should eq 'Goodbye, Jerry!' }
+  specify {
+    lambda { Foo.new.greet(1,2,3,4,5,6,7) }.should raise_error(NoMethodError)
+  }
+
+  specify { subject.options(bar: :baz, one: 1, many: 2).should == {bar: :baz, one: 1, many: 2} }
+
+  specify { subject.hashable(:male, {foo: :bar}, :female).should eq :foo_bar }
+  specify { subject.hashable(:male, {foo: :baz}, :female).should eq :baz }
+  specify { subject.hashable(:male, {foo: 1, bar: 2}, :female).should eq [1, 2] }
+  specify { subject.hashable(:male, {foo: 1, baz: 2}, :female).should eq 1 }
+  specify { subject.hashable(:male, {bar: :baz}, :female).should eq :unbound }
+  specify { subject.hashable(:male, {}, :female).should eq :empty }
+
+  specify { subject.recurse.should eq 'w00t!' }
+  specify { subject.recurse(:match).should eq 'w00t!' }
+  specify { subject.recurse(:super).should eq 'Hello, World!' }
+  specify { subject.recurse(:instance).should eq name }
+  specify { subject.recurse(:foo).should eq :foo }
+
+  specify { subject.concat(1, 1).should eq 2 }
+  specify { subject.concat(1, 'shoe').should eq '1 shoe' }
+  specify { subject.concat('shoe', 'fly').should eq 'shoefly' }
+  specify { subject.concat(1, 2.9).should eq 3 }
+
+  specify { subject.all(:one, 'a', 'bee', :see).should == ['a', 'bee', :see] }
+  specify { subject.all(:one, 1, 'bee', :see).should == [1, 'bee', :see] }
+  specify { subject.all(1, 'a', 'bee', :see).should == ['a', ['bee', :see]] }
+  specify { subject.all('a', 'bee', :see).should == ['a', 'bee', :see] }
+  specify { lambda { subject.all }.should raise_error(NoMethodError) }
+
+  specify { subject.old_enough(20).should be_true }
+  specify { subject.old_enough(10).should be_false }
+
+  specify { subject.right_age(20).should be_true }
+  specify { subject.right_age(10).should be_false }
+  specify { subject.right_age(110).should be_false }
+
+  specify { subject.wrong_age(20).should be_false }
+  specify { subject.wrong_age(10).should be_true }
+  specify { subject.wrong_age(110).should be_true }
+
+  context 'inheritance' do
+
+    specify { Fizzbuzz.new.greet(:male, 'Jerry').should eq 'Hello, Mr. Jerry!' }
+    specify { Fizzbuzz.new.greet(:female, 'Jeri').should eq 'Hello, Ms. Jeri!' }
+    specify { Fizzbuzz.new.greet(:unknown, 'Jerry').should eq 'Hello, Jerry!' }
+    specify { Fizzbuzz.new.greet(nil, 'Jerry').should eq 'Goodbye, Jerry!' }
+
+    specify { Fizzbuzz.new.who(5).should eq 15 }
+    specify { Fizzbuzz.new.who().should eq 0 }
+    specify { 
+      lambda {
+        Fizzbuzz.new.who('Jerry', 'secret middle name', "D'Antonio")
+      }.should raise_error(NoMethodError)
+    }
+
+    specify { Fizzbuzz.new.boom_boom_room.should eq 'zoom zoom zoom' }
+  end
+end

data/spec/functional/pattern_matching_spec.rb

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