pattern-matching 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dc55948d3772a5d4805826b923d12ae1f84f09cd
-  data.tar.gz: 6cf392b7bd93afe0e752c0fca586c2454ca583c1
+  metadata.gz: 26d3f6768306dd2dba389a7dd481e135417164de
+  data.tar.gz: 5bdc90e25e848b7de5ce67d58f7cce70d1a7e434
 SHA512:
-  metadata.gz: 630fb32894b0074e0e3f273f8d83c37e845c1becc3609e532d226e2e7308389bf744296d9ea411fa8e0b2dbb3c51f21c87e22db37db46726128d4be6dbbd0a15
-  data.tar.gz: 9369b4042e2cd7760cd2ade36aa5c7e8cdc545f5071e20b67af0c0f98e6971ba17c193899ff6fdd8f6efd1608093e3b4530d129f3f8e16419a66af051224c254
+  metadata.gz: e6fd87d44de49a937de38e70e42c7ab470b0afce1f20fb5ef64ecb949234ce168b0ba75713394457c75c7de02565a86ee47eee26ea2f6b04b7a1e8da8b7368b2
+  data.tar.gz: fb843fe146735c3603eb641b0e2dc790da3be503889a13e8b737844598b2012fceb2f48974dda9aa955c0147348fa1dea784edfb4d2e647eb0b619d2636dd4a4

data/README.md

@@ -4,6 +4,14 @@ A gem for adding Erlang-style pattern matching to Ruby classes.
 
 *NOTE: This is a work in progress. Expect changes.*
 
+The project is hosted on the following sites:
+
+* [RubyGems project page](https://rubygems.org/gems/pattern-matching)
+* [Source code on GitHub](https://github.com/jdantonio/pattern_matching)
+* [Continuous integration on Travis-CI](https://travis-ci.org/jdantonio/pattern_matching)
+* [Dependency tracking on Gemnasium](https://gemnasium.com/jdantonio/pattern_matching)
+* [Follow me on Twitter](https://twitter.com/jerrydantonio)
+
 ## Introduction
 
 [Ruby](http://www.ruby-lang.org/en/) is my favorite programming by far. As much as I love Ruby I've always been a little disappointed that Ruby doesn't support function overloading. Function overloading tends to reduce branching and keep functions signatures simpler. No sweat, I learned to do without. Then I started programming in [Erlang](http://www.erlang.org/)…
@@ -16,7 +24,8 @@ I've really started to enjoy working in Erlang. Erlang is good at all the things
 * Keep the semantics as idiomatic Ruby as possible
 * Support features that make sense in Ruby
 * Exclude features that only make sense in Erlang
-* Avoid using #method_missing
+* Avoid using *method_missing*
+* Keep it small (currently at 72 LOC)
 
 ### Features
 
@@ -33,26 +42,230 @@ I've really started to enjoy working in Erlang. Erlang is good at all the things
 
 ### To-do
 
-* Variable-length argument lists
 * Matching against array elements
 * Guard clauses
 * Support class methods
 * Support module instance methods
 * Support module methods
 
+## Supported Ruby versions
+
+MRI 1.9.x and above. Anything else and your mileage may vary.
+
 ## Install
 
-    gem install pattern-matching
+```shell
+gem install pattern-matching
+```
 
 or add the following line to Gemfile:
 
-    gem 'pattern-matching
+```ruby
+gem 'pattern-matching'
+```
 
 and run `bundle install` from your shell.
 
-## Supported Ruby versions
+## Usage
 
-MRI 1.9.x and above. Anything else and your mileage may vary.
+First, familiarize yourself with Erlang [pattern matching](http://learnyousomeerlang.com/syntax-in-functions#pattern-matching).
+This gem may not make much sense if you don't understand how Erlang dispatches
+functions.
+
+In the Ruby class file where you want to use pattern matching, require the
+*pattern_matching* gem:
+
+```ruby
+require 'pattern_matching'
+```
+
+Then include `PatternMatching` in your class:
+
+```ruby
+require 'pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  ...
+
+end
+```
+
+You can then define functions with `defn` instead of the normal *def* statement.
+The syntax for `defn` is:
+
+```ruby
+defn(:symbol_name_of_function, zero, or, more, parameters) { |block, arguments|
+  # code to execute
+}
+```
+You can then call your new function just like any other:
+
+```ruby
+require 'pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  defn(:hello) {
+    puts "Hello, World!"
+  }
+end
+
+foo = Foo.new
+foo.hello #=> "Hello, World!"
+```
+
+Patterns to match against are included in the parameter list:
+
+```ruby
+defn(:greet, :male) {
+  puts "Hello, sir!"
+}
+
+defn(:greet, :female) {
+  puts "Hello, ma'am!"
+}
+
+...
+
+foo.hello(:male)   #=> "Hello, sir!"
+foo.hello(:female) #=> "Hello, ma'am!"
+```
+
+If a particular method call can not be matched a *NoMethodError* is thrown with
+a reasonably helpful error message:
+
+```ruby
+foo.greet(:unknown) #=> NoMethodError: no method `greet` matching [:unknown] found for class Foo
+foo.greet           #=> NoMethodError: no method `greet` matching [] found for class Foo
+```
+
+Parameters that are expected to exist but that can take any value are considered
+*unbound* parameters. Unbound parameters are specified by the `_` underscore
+character or `UNBOUND`:
+
+```ruby
+defn(:greet, _) do |name|
+  "Hello, #{name}!"
+end
+
+defn(:greet, UNBOUND, UNBOUND) do |first, last|
+  "Hello, #{first} #{last}!"
+end
+
+...
+
+foo.greet('Jerry') #=> "Hello, Jerry!"
+```
+
+All unbound parameters will be passed to the block in the order they are specified in the definition:
+
+```ruby
+defn(:greet, _, _) do |first, last|
+  "Hello, #{first} #{last}!"
+end
+
+...
+
+foo.greet('Jerry', "D'Antonio") #=> "Hello, Jerry D'Antonio!"
+```
+
+If for some reason you don't care about one or more unbound parameters within
+the block you can use the `_` underscore character in the block parameters list
+as well:
+
+```ruby
+defn(:greet, _, _, _) do |first, _, last|
+  "Hello, #{first} #{last}!"
+end
+
+...
+
+foo.greet('Jerry', "I'm not going to tell you my middle name!", "D'Antonio") #=> "Hello, Jerry D'Antonio!"
+```
+
+Hash parameters can match against specific keys and either bound or unbound parameters. This allows for function dispatch by hash parameters without having to dig through the hash:
+
+```ruby
+defn(:hashable, {foo: :bar}) { |opts|
+  :foo_bar
+}
+defn(:hashable, {foo: _}) { |f|
+  f
+}
+
+...
+
+foo.hashable({foo: :bar})      #=> :foo_bar
+foo.hashable({foo: :baz})      #=> :baz
+```
+
+The Ruby idiom of the final parameter being a hash is also supported:
+
+```ruby
+defn(:options, _) { |opts|
+  opts
+}
+
+...
+
+foo.options(bar: :baz, one: 1, many: 2)
+```
+
+As is the Ruby idiom of variable-length argument lists. The constant `ALL` as the last parameter
+will match one or more arguments and pass them to the block as an array:
+
+```ruby
+defn(:baz, Integer, ALL) { |int, args|
+  [int, args]
+}
+defn(:baz, ALL) { |args|
+  args
+}
+```
+
+Superclass polymorphism is supported as well. If an object cannot match a method
+signature it will defer to the parent class:
+
+```ruby
+class Bar
+  def greet
+    return 'Hello, World!'
+  end
+end
+
+class Foo < Bar
+  include PatternMatching
+
+  defn(:greet, _) do |name|
+    "Hello, #{name}!"
+  end
+end
+
+...
+
+foo.greet('Jerry') #=> "Hello, Jerry!"
+foo.greet          #=> "Hello, World!"
+```
+
+### Order Matters
+
+As with Erlang, the order of pattern matches is significant. Patterns will be matched
+*in the order declared* and the first match will be used. If a particular function call
+can be matched by more than one pattern, the *first matched pattern* will be used. It
+is the programmer's responsibility to ensure patterns are declared in the correct order.
+
+### Blocks and Procs and Lambdas, oh my!
+
+When using this gem it is critical to remember that `defn` takes a block and
+that blocks in Ruby have special rules. There are [plenty](https://www.google.com/search?q=ruby+block+proc+lambda)
+of good tutorials on the web explaining [blocks](http://www.robertsosinski.com/2008/12/21/understanding-ruby-blocks-procs-and-lambdas/)
+and [Procs](https://coderwall.com/p/_-_mha) and [lambdas](http://railsguru.org/2010/03/learn-ruby-procs-blocks-lambda/)
+in Ruby. Please read them. Please don't submit a bug report if you use a
+`return` statement within your `defn` and your code blows up with a
+[LocalJumpError](http://ruby-doc.org/core-2.0/LocalJumpError.html). 
 
 ## Examples
 
@@ -64,34 +277,38 @@ This example is based on [Syntax in defnctions: Pattern Matching](http://learnyo
 
 Erlang:
 
-    greet(male, Name) ->
-      io:format("Hello, Mr. ~s!", [Name]);
-    greet(female, Name) ->
-      io:format("Hello, Mrs. ~s!", [Name]);
-    greet(_, Name) ->
-      io:format("Hello, ~s!", [Name]).
+```erlang
+greet(male, Name) ->
+  io:format("Hello, Mr. ~s!", [Name]);
+greet(female, Name) ->
+  io:format("Hello, Mrs. ~s!", [Name]);
+greet(_, Name) ->
+  io:format("Hello, ~s!", [Name]).
+```
 
 Ruby:
 
-    require 'pattern_matching'
+```ruby
+require 'pattern_matching'
 
-    class Foo
-      include PatternMatching
-  
-      defn(:greet, _) do |name|
-        "Hello, #{name}!"
-      end
-  
-      defn(:greet, :male, _) { |name|
-        "Hello, Mr. #{name}!"
-      }
-      defn(:greet, :female, _) { |name|
-        "Hello, Ms. #{name}!"
-      }
-      defn(:greet, _, _) { |_, name|
-        "Hello, #{name}!"
-      }
-    end
+class Foo
+  include PatternMatching
+
+  defn(:greet, _) do |name|
+    "Hello, #{name}!"
+  end
+
+  defn(:greet, :male, _) { |name|
+    "Hello, Mr. #{name}!"
+  }
+  defn(:greet, :female, _) { |name|
+    "Hello, Ms. #{name}!"
+  }
+  defn(:greet, _, _) { |_, name|
+    "Hello, #{name}!"
+  }
+end
+```
 
 ### Simple Functions with Overloading
 
@@ -99,83 +316,161 @@ This example is based on [Syntax in defnctions: Pattern Matching](http://learnyo
 
 Erlang:
 
-    greet(Name) ->
-      io:format("Hello, ~s!", [Name]).
+```erlang
+greet(Name) ->
+  io:format("Hello, ~s!", [Name]).
 
-    greet(male, Name) ->
-      io:format("Hello, Mr. ~s!", [Name]);
-    greet(female, Name) ->
-      io:format("Hello, Mrs. ~s!", [Name]);
-    greet(_, Name) ->
-      io:format("Hello, ~s!", [Name]).
+greet(male, Name) ->
+  io:format("Hello, Mr. ~s!", [Name]);
+greet(female, Name) ->
+  io:format("Hello, Mrs. ~s!", [Name]);
+greet(_, Name) ->
+  io:format("Hello, ~s!", [Name]).
+```
 
 Ruby:
 
-    require 'pattern_matching'
-
-    class Foo
-      include PatternMatching
-  
-      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}!"
-      }
-    end
+```ruby
+require 'pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  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}!"
+  }
+end
+```
 
 ### Matching by Class/Datatype
 
-Ruby:
-
-    require 'pattern_matching'
-
-    class Foo
-      include PatternMatching
-  
-      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, _) { |first, second|
-        first + second.to_i
-      }
-    end
+```ruby
+require 'pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  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, _) { |first, second|
+    first + second.to_i
+  }
+end
+```
 
 ### Matching a Hash Parameter
 
-Ruby:
+```ruby
+require 'pattern_matching'
 
-    require 'pattern_matching'
-
-    class Foo
-      include PatternMatching
-
-      defn(:hashable, {foo: :bar}) { |opts|
-        # matches any hash with key :foo and value :bar
-        :foo_bar
-      }
-      defn(:hashable, {foo: _}) { |opts|
-        # matches any hash with :key foo regardless of value
-        :foo_unbound
-      }
-      defn(:hashable, {}) { |opts|
-        # matches any hash
-        :unbound_unbound
-      }
-    end
+class Foo
+  include PatternMatching
+  
+  defn(:hashable, {foo: :bar}) { |opts|
+    # matches any hash with key :foo and value :bar
+    :foo_bar
+  }
+  defn(:hashable, {foo: _, bar: _}) { |f, b|
+    # matches any hash with keys :foo and :bar
+    # passes the values associated with those keys to the block
+    [f, b]
+  }
+  defn(:hashable, {foo: _}) { |f|
+    # matches any hash with key :foo
+    # passes the value associated with that key to the block
+    # must appear AFTER the prior match or it will override that one
+    f
+  }
+  defn(:hashable, {}) { ||
+    # matches an empty hash
+    :empty
+  }
+  defn(:hashable, _) { |opts|
+    # matches any hash (or any other value)
+    opts
+  }
+end
+
+...
+
+foo.hashable({foo: :bar})      #=> :foo_bar
+foo.hashable({foo: :baz})      #=> :baz
+foo.hashable({foo: 1, bar: 2}) #=> [1, 2] 
+foo.hashable({foo: 1, baz: 2}) #=> 1
+foo.hashable({bar: :baz})      #=> {bar: :baz}
+foo.hashable({})               #=> :empty 
+```
+
+### Variable Length Argument Lists with ALL
+
+```ruby
+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
+}
+
+...
+
+foo.all(:one, 'a', 'bee', :see) #=> ['a', 'bee', :see]
+foo.all(:one, 1, 'bee', :see)   #=> [1, 'bee', :see]
+foo.all(1, 'a', 'bee', :see)    #=> ['a', ['bee', :see]]
+foo.all('a', 'bee', :see)       #=> ['a', 'bee', :see]
+foo.all()                       #=> NoMethodError: no method `all` matching [] found for class Foo
+```
+
+## Copyright
+
+*PatternMatching* is Copyright &copy; 2013 [Jerry D'Antonio](https://twitter.com/jerrydantonio).
+It is free software and may be redistributed under the terms specified in the LICENSE file.
+
+## License
+
+Released under the MIT license.
+
+http://www.opensource.org/licenses/mit-license.php  
+
+> Permission is hereby granted, free of charge, to any person obtaining a copy  
+> of this software and associated documentation files (the "Software"), to deal  
+> in the Software without restriction, including without limitation the rights  
+> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell  
+> copies of the Software, and to permit persons to whom the Software is  
+> furnished to do so, subject to the following conditions:  
+> 
+> The above copyright notice and this permission notice shall be included in  
+> all copies or substantial portions of the Software.  
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR  
+> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,  
+> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE  
+> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER  
+> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,  
+> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN  
+> THE SOFTWARE.  

data/lib/pattern_matching.rb

@@ -1,20 +1,22 @@
 module PatternMatching
 
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 
   UNBOUND = Unbound = Class.new
+  ALL = All = Class.new
 
   def self.included(base)
 
     base.instance_variable_set(:@__function_pattern_matches__, Hash.new)
 
     def __match_pattern__(args, pattern) # :nodoc:
-      return unless args.length == pattern.length
+      return unless (pattern.last == ALL && args.length >= pattern.length) \
+        || (args.length == pattern.length)
       pattern.each_with_index do |p, i|
+        break if p == ALL && i+1 == pattern.length
         arg = args[i]
         next if p.is_a?(Class) && arg.is_a?(p)
-        if p.is_a?(Hash) && arg.is_a?(Hash)
-          next if p.empty?
+        if p.is_a?(Hash) && arg.is_a?(Hash) && ! p.empty?
           p.each do |key, value|
             return false unless arg.has_key?(key)
             next if value == UNBOUND
@@ -29,26 +31,30 @@ module PatternMatching
 
     def __pattern_match__(func, *args, &block) # :nodoc:
       clazz = self.class
+      args = args.first
 
-      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)
-      matchers = matchers[func]
+      # get the array of matchers for this function
+      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)[func]
 
       # scan through all patterns for this function
-      match = nil
-      matchers.each do |matcher|
-        if __match_pattern__(args.first, matcher.first)
-          match = matcher
-          break(matcher)
-        end
-      end
+      index = matchers.index{|matcher| __match_pattern__(args, matcher.first)}
 
-      # if a match is found call the block
-      if match.nil?
+      if index.nil?
         [:nomatch, nil]
       else
+        # if a match is found call the block
         argv = []
+        match = matchers[index]
         match.first.each_with_index do |p, i|
-          argv << args.first[i] if p == UNBOUND || p.is_a?(Class) || p.is_a?(Hash)
+          if p == ALL && i == match.first.length-1
+            argv << args[(i..args.length)].reduce([]){|memo, arg| memo << arg }
+          elsif p.is_a?(Hash) && p.values.include?(UNBOUND)
+            p.each do |key, value|
+              argv << args[i][key] if value == UNBOUND
+            end
+          elsif p.is_a?(Hash) || p == UNBOUND || p.is_a?(Class)
+            argv << args[i] 
+          end
         end
         return [:ok, self.instance_exec(*argv, &match.last)]
       end
@@ -56,6 +62,9 @@ module PatternMatching
 
     class << base
 
+      UNBOUND = PatternMatching::UNBOUND
+      ALL = PatternMatching::ALL
+
       def _() # :nodoc:
         return UNBOUND
       end

data/spec/integration_spec.rb

@@ -39,11 +39,21 @@ describe 'integration' do
     defn(:hashable, _, {foo: :bar}, _) { |_, opts, _|
       :foo_bar
     }
-    defn(:hashable, _, {foo: _}, _) { |_, opts, _|
-      :foo_unbound
+    defn(:hashable, _, {foo: _, bar: _}, _) { |_, f, b, _|
+      [f, b]
     }
-    defn(:hashable, _, {}, _) { |_, opts, _|
-      :unbound_unbound
+    defn(:hashable, _, {foo: _}, _) { |_, f, _|
+      f
+    }
+    defn(:hashable, _, {}, _) {
+      :empty
+    }
+    defn(:hashable, _, _, _) { |_, _, _|
+      :unbound
+    }
+
+    defn(:options, _) { |opts|
+      opts
     }
 
     defn(:recurse) {
@@ -71,9 +81,22 @@ describe 'integration' do
     defn(:concat, String, String) { |first, second|
       first + second
     }
-    defn(:concat, Integer, _) { |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
+    }
   end
 
   let(:name) { 'Pattern Matcher' }
@@ -88,10 +111,14 @@ describe 'integration' do
   specify { subject.greet(:unknown, 'Jerry').should eq 'Hello, Jerry!' }
   specify { subject.greet(nil, 'Jerry').should eq 'Goodbye, Jerry!' }
 
+  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 :foo_unbound }
-  specify { subject.hashable(:male, {foo: :bar, bar: :baz}, :female).should eq :foo_bar }
-  specify { subject.hashable(:male, {bar: :baz}, :female).should eq :unbound_unbound }
+  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!' }
@@ -104,4 +131,10 @@ describe 'integration' do
   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) }
+
 end

data/spec/pattern_matching_spec.rb

@@ -277,20 +277,24 @@ describe PatternMatching do
 
   context 'functions with hash arguments' do
 
-    it 'matches when all hash keys and values match' do
+    it 'matches an empty argument hash with an empty parameter hash' do
 
-      subject.defn(:foo, {bar: :baz}) { true }
-      subject.new.foo(bar: :baz).should be_true
+      subject.defn(:foo, {}) { true }
+      subject.new.foo({}).should be_true
 
       lambda {
         subject.new.foo({one: :two})
       }.should raise_error(NoMethodError)
     end
 
-    it 'matches when the pattern uses an empty hash' do
+    it 'matches when all hash keys and values match' do
 
-      subject.defn(:foo, {}) { true }
+      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
@@ -305,9 +309,15 @@ describe PatternMatching do
       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: PatternMatching::UNBOUND}) { |args| args }
+      subject.defn(:foo, {bar: :baz}) { |opts| opts }
       subject.new.foo(bar: :baz).should == {bar: :baz}
     end
 
@@ -319,6 +329,23 @@ describe PatternMatching do
         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
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pattern-matching
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-05 00:00:00.000000000 Z
+date: 2013-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler