pattern-matching 0.1.0 → 0.2.0

data/lib/pattern_matching.rb

@@ -1,99 +1,133 @@
-module PatternMatching
-
-  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 (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
-        end
-        return false unless p == UNBOUND || p == arg
-      end
-      return true
-    end
-
-    def __pattern_match__(func, *args, &block) # :nodoc:
-      clazz = self.class
-      args = args.first
-
-      # get the array of matchers for this function
-      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)[func]
-
-      # scan through all patterns for this function
-      index = matchers.index{|matcher| __match_pattern__(args, matcher.first)}
-
-      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|
-          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
-    end
-
-    class << base
-
-      UNBOUND = PatternMatching::UNBOUND
-      ALL = PatternMatching::ALL
-
-      def _() # :nodoc:
-        return UNBOUND
-      end
-
-      def __add_pattern_for__(func, *args, &block) # :nodoc:
-        block = Proc.new{} unless block_given?
-        matchers = self.instance_variable_get(:@__function_pattern_matches__)
-        matchers[func] = [] unless matchers.has_key?(func)
-        matchers[func] << [args, block]
-      end
-
-      def defn(func, *args, &block)
-
-        block = Proc.new{} unless block_given?
-        __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
-              super(*args, &block)
-            rescue NoMethodError
-              raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
-            end
-          end
-        end
-      end
-
-    end
-  end
-end
+module PatternMatching
+
+  VERSION = '0.2.0'
+
+  UNBOUND = Class.new
+  ALL = Class.new
+
+  def self.included(base)
+
+    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
+        end
+        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] 
+        end
+      end
+      return argv
+    end
+
+    def __pattern_match__(func, *args, &block) # :nodoc:
+      clazz = self.class
+      args = args.first
+
+      # get the array of matchers for this function
+      matchers = clazz.instance_variable_get(:@__function_pattern_matches__)[func]
+
+      # 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
+        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
+    end
+
+    class << base
+
+      public
+
+      def _() # :nodoc:
+        return UNBOUND
+      end
+
+      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
+              super(*args, &block)
+            rescue NoMethodError
+              raise NoMethodError.new("no method `#{func}` matching #{args} found for class #{self.class}")
+            end
+          end
+        end
+
+        return guard.new(func, self, pattern)
+      end
+
+      private
+
+      def __add_pattern_for__(func, *args, &block) # :nodoc:
+        block = Proc.new{} unless block_given?
+        matchers = self.instance_variable_get(:@__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,140 +1,170 @@
-require 'spec_helper'
-require 'ostruct'
-
-describe 'integration' do
-
-  class Bar
-
-    def greet
-      return 'Hello, World!'
-    end
-  end
-
-  class Foo < Bar
-    include PatternMatching
-
-    attr_accessor :name
-
-    def initialize(name = 'baz')
-      @name = name
-    end
-
-    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
-    }
-  end
-
-  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 { 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) }
-
-end
+require 'spec_helper'
+require 'ostruct'
+
+describe 'integration' do
+
+  class Bar
+
+    def greet
+      return 'Hello, World!'
+    end
+  end
+
+  class Foo < Bar
+    include PatternMatching
+
+    attr_accessor :name
+
+    def initialize(name = 'baz')
+      @name = name
+    end
+
+    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
+
+  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 { 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 }
+
+end