pattern-matching 0.2.0 → 0.3.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    ZDIzMzQ1NTgyM2ZlNTVkMmEzYmI1YTNhZWMzODJjYWY5ODkxNzI5NQ==
+    NTczMjQ3ODhmZmM1ZTFjYWI0NDc3Mjk4ZDg0ZWNiZTI2MTEyMWUzNg==
   data.tar.gz: !binary |-
-    MTcyYWU2ZjE1MGYxMWQxYWRkMWQwZGEwMDZmNDNiZWRkM2JjNjk1YQ==
+    YzQwN2I4N2VhNDhlOGJjZjM0MmZjNGI1OTFkZDE1NWNhMjA3ODU5ZQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZDdmMjE5NjFhOTI1MDE4MzFkZjRjMDgxZWY2OGMzNzNlODczMjQ4ZjRiZTE2
-    MjZkZDNhYjFhOTBmODJiMTFlYzQ5ZjkwNzQzOTRjZmM5YjQzZjI3MTg3MTNi
-    ZGI5MmI4ZWNmMTYyMTJkNDA3NTc3ZjJlNGEzMzM4NWE0Mzk4MTE=
+    YTFiNzcwMzg0NmQ2OGI5MmI2MTA1Njg1YzE2NjIzMDJiNjg5NDk4OGZmMDUw
+    YzlmMGI3NzJlMWNmNGViYTcwN2MxODY4MzA4OGRhNzZjOTJlOTg1ODUzZTcy
+    NzYyZjgzZjIzZmE2ZjFjMjEzZTIxZDE2OGJlNDEzMDE0MDNkOTU=
   data.tar.gz: !binary |-
-    MzJkN2M4M2YzYTQyODkzODI5YzlkNjZmMWFjZDAzY2VlNTg0OGVjOWUzYmRh
-    NzJiNjFkOWI0ODY5NjE4ODcyZTBiYjljNGYyYWQ5ZGE5ZmNjOThmZTY5YTRh
-    M2M5NThkNmQ3NGNkMDJjYWEwYTNhZWYwZjJkYmNlYzQ5YmIwNzc=
+    MjIxM2ViMmYzY2UyNDhhMWViNzI0NTgxODNmODRmZGEyODY4MGY0YWM0Mjcw
+    NWVmZjg1NDhjMjZjNDZjNzI2NTRmNjY3YzBlZjQwYjM4MmZkZmE2NzUwZjYx
+    OWMwMTRkOGJiMzBkNDA4OTY1NmU2NmY3NmQ1M2Q3YzdmOWE2NDc=

data/README.md

@@ -14,9 +14,17 @@ The project is hosted on the following sites:
 
 ## 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/)…
-
-I've really started to enjoy working in Erlang. Erlang is good at all the things Ruby is bad at and vice versa. Together, Ruby and Erlang make me happy. My favotite Erlang feature is, without question, [pattern matching](http://learnyousomeerlang.com/syntax-in-functions#pattern-matching). Pattern matching is like function overloading cranked to 11. So one day I was musing on Twitter and one of my friends responded with "Build it!" So I did. And here it is.
+[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 function signatures simpler.
+No sweat, I learned to do without. Then I started programming in [Erlang](http://www.erlang.org/)...
+
+I've really started to enjoy working in Erlang. Erlang is good at all the things Ruby is bad
+at and vice versa. Together, Ruby and Erlang make me happy. My favorite Erlang feature is,
+without question, [pattern matching](http://learnyousomeerlang.com/syntax-in-functions#pattern-matching).
+Pattern matching is like function overloading cranked to 11. So one day I was musing on Twitter
+that I'd like to see Erlang-stype pattern matching in Ruby and one of my friends responded "Build it!"
+So I did. And here it is.
 
 ### Goals
 
@@ -30,16 +38,21 @@ I've really started to enjoy working in Erlang. Erlang is good at all the things
 
 ### Features
 
-* Basic pattern matching for instance methods.
+* Pattern matching for instance methods.
+* Pattern matching for object constructors.
 * Parameter count matching
-* Mathing against primitive values
+* Matching against primitive values
 * Matching by class/datatype
 * Matching against specific key/vaue pairs in hashes
 * Matching against the presence of keys within hashes
-* Reasonable error messages when no match is found
-* Dispatching to superclass methods when no match is found
+* Implicit hash for last parameter
+* Variable-length parameter lists
+* Guard clauses
 * Recursive calls to other pattern matches
+* Recursive calls to superclass pattern matches
 * Recursive calls to superclass methods
+* Dispatching to superclass methods when no match is found
+* Reasonable error messages when no match is found
 
 ### To-do
 
@@ -373,6 +386,19 @@ class Foo
 end
 ```
 
+### Constructor Overloading
+
+```ruby
+require 'pattern_matching'
+
+class Foo
+  include PatternMatching
+
+  defn(:initialize) { @name = 'baz' }
+  defn(:initialize, _) {|name| @name = name.to_s }
+end
+```
+
 ### Matching by Class/Datatype
 
 ```ruby

data/lib/pattern_matching.rb

@@ -1,79 +1,93 @@
+require 'pp'
+
 module PatternMatching
 
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 
   UNBOUND = Class.new
   ALL = Class.new
 
-  def self.included(base)
+  private
 
-    base.instance_variable_set(:@__function_pattern_matches__, Hash.new)
-
-    private
-
-    def __match_pattern__(args, pattern) # :nodoc:
-      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) && ! p.empty?
-          p.each do |key, value|
-            return false unless arg.has_key?(key)
-            next if value == UNBOUND
-            return false unless arg[key] == value
-          end
-          next
+  class Guard # :nodoc:
+    def initialize(func, clazz, matcher) # :nodoc:
+      @func = func
+      @clazz = clazz
+      @matcher = matcher
+    end
+    def when(&block) # :nodoc:
+      unless block_given?
+        raise ArgumentError.new("block missing for `when` guard on function `#{@func}` of class #{@clazz}")
+      end
+      @matcher[@matcher.length-1] = block
+      return nil
+    end
+  end
+
+  def self.__match_pattern__(args, pattern) # :nodoc:
+    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) && ! p.empty?
+        p.each do |key, value|
+          return false unless arg.has_key?(key)
+          next if value == UNBOUND
+          return false unless arg[key] == value
         end
-        return false unless p == UNBOUND || p == arg
+        next
       end
-      return true
+      return false unless p == UNBOUND || p == arg
     end
+    return true
+  end
 
-    def __unbound_args__(match, args) # :nodoc:
-      argv = []
-      match.first.each_with_index do |p, i|
-        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] 
+  def self.__unbound_args__(match, args) # :nodoc:
+    argv = []
+    match.first.each_with_index do |p, i|
+      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
-      return argv
     end
+    return argv
+  end
 
-    def __pattern_match__(func, *args, &block) # :nodoc:
-      clazz = self.class
-      args = args.first
+  def self.__pattern_match__(clazz, func, *args, &block) # :nodoc:
+    args = args.first
 
-      # get the array of matchers for this function
-      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)[func]
+    # get the array of matchers for this function
+    matchers = clazz.__function_pattern_matches__[func]
+    return [:nodef, nil] if matchers.nil?
 
-      # scan through all patterns for this function
-      index = matchers.index do |matcher|
-        if __match_pattern__(args, matcher.first)
-          if matcher.last.nil?
-            true # no guard clause
-          else
-            self.instance_exec(*__unbound_args__(matcher, args), &matcher.last)
-          end
+    # scan through all patterns for this function
+    index = matchers.index do |matcher|
+      if PatternMatching.__match_pattern__(args, matcher.first)
+        if matcher.last.nil?
+          true # no guard clause
+        else
+          self.instance_exec(*PatternMatching.__unbound_args__(matcher, args), &matcher.last)
         end
       end
+    end
 
-      if index.nil?
-        return [:nomatch, nil]
-      else
-        # if a match is found call the block
-        match = matchers[index]
-        argv = __unbound_args__(match, args)
-        return [:ok, self.instance_exec(*argv, &match[1])]
-      end
+    if index.nil?
+      return [:nomatch, nil]
+    else
+      return [:ok, matchers[index]]
     end
+  end
+
+  protected
+
+  def self.included(base)
 
     class << base
 
@@ -85,49 +99,45 @@ module PatternMatching
 
       def defn(func, *args, &block)
 
-        guard = Class.new do
-          def initialize(func, clazz, matcher)
-            @func = func
-            @clazz = clazz
-            @matcher = matcher
-          end
-          def when(&block)
-            unless block_given?
-              raise ArgumentError.new("block missing for `when` guard on function `#{@func}` of class #{@clazz}")
-            end
-            @matcher[@matcher.length-1] = block
-            return nil
-          end
-        end
-
         block = Proc.new{} unless block_given?
         pattern = __add_pattern_for__(func, *args, &block)
 
         unless self.instance_methods(false).include?(func)
-          self.send(:define_method, func) do |*args, &block|
-            result, value = __pattern_match__(func, args, block)
-            return value if result == :ok
-            begin
+
+          define_method(func) do |*args, &block|
+            result, match = PatternMatching.__pattern_match__(self.method(func).owner, func, args, block)
+            if result == :ok
+              # if a match is found call the block
+              argv = PatternMatching.__unbound_args__(match, args)
+              return self.instance_exec(*argv, &match[1])
+            elsif result == :nodef
               super(*args, &block)
-            rescue NoMethodError
-              raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
+            else
+              begin
+                super(*args, &block)
+              rescue NoMethodError, ArgumentError
+                raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
+              end
             end
           end
         end
 
-        return guard.new(func, self, pattern)
+        return PatternMatching::Guard.new(func, self, pattern)
       end
 
-      private
+      public
+
+      def __function_pattern_matches__ # :nodoc:
+        @__function_pattern_matches__ ||= Hash.new
+      end
 
       def __add_pattern_for__(func, *args, &block) # :nodoc:
         block = Proc.new{} unless block_given?
-        matchers = self.instance_variable_get(:@__function_pattern_matches__)
+        matchers = self.__function_pattern_matches__
         matchers[func] = [] unless matchers.has_key?(func)
         matchers[func] << [args, block, nil]
         return matchers[func].last
       end
-
     end
   end
 end

data/spec/integration_spec.rb

@@ -1,10 +1,7 @@
 require 'spec_helper'
 require 'ostruct'
 
-describe 'integration' do
-
   class Bar
-
     def greet
       return 'Hello, World!'
     end
@@ -15,9 +12,8 @@ describe 'integration' do
 
     attr_accessor :name
 
-    def initialize(name = 'baz')
-      @name = name
-    end
+    defn(:initialize) { @name = 'baz' }
+    defn(:initialize, _) {|name| @name = name.to_s }
 
     defn(:greet, _) do |name|
       "Hello, #{name}!"
@@ -97,27 +93,46 @@ describe 'integration' do
     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) }
 
@@ -129,6 +144,9 @@ describe 'integration' do
   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} }
 
@@ -167,4 +185,21 @@ describe 'integration' do
   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/pattern_matching_spec.rb

@@ -32,6 +32,21 @@ describe PatternMatching do
     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
@@ -64,7 +79,7 @@ describe PatternMatching do
         end
       end
 
-      class UnmatchedCallTesterSubclass  < UnmatchedCallTesterSuperclass
+      class UnmatchedCallTesterSubclass < UnmatchedCallTesterSuperclass
         include PatternMatching
         defn(:foo) { 'baz' }
       end
@@ -89,7 +104,7 @@ describe PatternMatching do
         end
       end
 
-      class RecursiveCallTesterSubclass  < RecursiveCallTesterSuperclass
+      class RecursiveCallTesterSubclass < RecursiveCallTesterSuperclass
         include PatternMatching
         defn(:foo, :bar) { foo(:baz) }
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pattern-matching
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-07 00:00:00.000000000 Z
+date: 2013-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -45,7 +45,7 @@ homepage: https://github.com/jdantonio/pattern_matching/
 licenses:
 - MIT
 metadata: {}
-post_install_message: Happy matching!
+post_install_message: start() -> io:format("Hello, World!").
 rdoc_options: []
 require_paths:
 - lib