pattern-matching 0.3.0 → 0.4.0

data/lib/behavior.rb

@@ -0,0 +1,59 @@
+def behavior_info(name, callbacks = {})
+  $__behavior_info__ ||= {}
+  $__behavior_info__[name.to_sym] = callbacks.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+end
+
+alias :behaviour_info :behavior_info
+alias :interface :behavior_info
+
+class Object
+  def behaves_as?(name)
+
+    name = name.to_sym
+    bi = $__behavior_info__[name]
+    return false if bi.nil?
+
+    bi.each do |method, arity|
+      begin
+        return false unless arity == :any || self.method(method).arity == arity
+      rescue NameError
+        return false
+      end
+    end
+
+    return true
+  end
+end
+
+def behavior(name)
+
+  name = name.to_sym
+  raise ArgumentError.new("undefined behavior '#{name}'") if $__behavior_info__[name].nil?
+
+  clazz = self.method(:behavior).receiver
+
+  unless clazz.instance_methods(false).include?(:behaviors)
+    class << clazz
+      def behaviors
+        @behaviors ||= []
+      end
+    end
+  end
+
+  clazz.behaviors << name
+
+  class << clazz
+    def new(*args, &block)
+      name = self.behaviors.first
+      obj = super
+      unless obj.behaves_as?(name)
+        raise ArgumentError.new("undefined callback functions in #{self} (behavior '#{name}')")
+      else
+        return obj
+      end
+    end
+  end
+end
+
+alias :behaviour :behavior
+alias :behaves_as :behavior

data/lib/behaviour.rb

@@ -0,0 +1,2 @@
+# Support the Scandinavian spelling
+require_relative 'behavior'

data/lib/pattern_matching.rb

@@ -1,143 +1,139 @@
-require 'pp'
-
-module PatternMatching
-
-  VERSION = '0.3.0'
-
-  UNBOUND = Class.new
-  ALL = Class.new
-
-  private
-
-  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
-        next
-      end
-      return false unless p == UNBOUND || p == arg
-    end
-    return true
-  end
-
-  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
-    end
-    return argv
-  end
-
-  def self.__pattern_match__(clazz, func, *args, &block) # :nodoc:
-    args = args.first
-
-    # 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 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
-      return [:ok, matchers[index]]
-    end
-  end
-
-  protected
-
-  def self.included(base)
-
-    class << base
-
-      public
-
-      def _() # :nodoc:
-        return UNBOUND
-      end
-
-      def defn(func, *args, &block)
-
-        block = Proc.new{} unless block_given?
-        pattern = __add_pattern_for__(func, *args, &block)
-
-        unless self.instance_methods(false).include?(func)
-
-          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)
-            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 PatternMatching::Guard.new(func, self, pattern)
-      end
-
-      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.__function_pattern_matches__
-        matchers[func] = [] unless matchers.has_key?(func)
-        matchers[func] << [args, block, nil]
-        return matchers[func].last
-      end
-    end
-  end
-end
+module PatternMatching
+
+  VERSION = '0.4.0'
+
+  UNBOUND = Class.new
+  ALL = Class.new
+
+  private
+
+  GUARD_CLAUSE = Class.new do # :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
+        next
+      end
+      return false unless p == UNBOUND || p == arg
+    end
+    return true
+  end
+
+  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
+    end
+    return argv
+  end
+
+  def self.__pattern_match__(clazz, func, *args, &block) # :nodoc:
+    args = args.first
+
+    matchers = clazz.__function_pattern_matches__[func]
+    return [:nodef, nil] if matchers.nil?
+
+    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
+      return [:ok, matchers[index]]
+    end
+  end
+
+  protected
+
+  def self.included(base)
+
+    class << base
+
+      public
+
+      def _() # :nodoc:
+        return UNBOUND
+      end
+
+      def defn(func, *args, &block)
+        unless block_given?
+          raise ArgumentError.new("block missing for definition of function `#{func}` on class #{self}")
+        end
+
+        pattern = __add_pattern_for__(func, *args, &block)
+
+        unless self.instance_methods(false).include?(func)
+
+          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])
+            else # if result == :nodef || result == :nomatch
+              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_CLAUSE.new(func, self, pattern)
+      end
+
+      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.__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/behavior_spec.rb

@@ -0,0 +1,239 @@
+require 'spec_helper'
+
+#behaviour_info(:gen_foo, foo: 0, bar: 1, baz: 2, boom: -1, bam: :any)
+
+#class Foo
+  #behavior(:gen_foo)
+
+  #def foo
+    #return 'foo/0'
+  #end
+
+  #def bar(one, &block)
+    #return 'bar/1'
+  #end
+
+  #def baz(one, two)
+    #return 'baz/2'
+  #end
+
+  #def boom(*args)
+    #return 'boom/-1'
+  #end
+
+  #def bam
+    #return 'bam!'
+  #end
+#end
+
+
+
+describe 'behavior/interface definitions' do
+
+  before(:each) do
+    $__behavior_info__ = {}
+  end
+
+  context 'behavior_info/2' do
+
+    it 'accepts a symbol name' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts a string name' do
+      behavior_info('gen_foo', foo: 0)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts zero function names' do
+      behavior_info(:gen_foo)
+      $__behavior_info__.keys.first.should eq :gen_foo
+    end
+
+    it 'accepts symbols for function names' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts strings as function names' do
+      behavior_info(:gen_foo, 'foo' => 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts numeric arity values' do
+      behavior_info(:gen_foo, foo: 0)
+      $__behavior_info__.values.first.should == {foo: 0}
+    end
+
+    it 'accepts :any as an arity value' do
+      behavior_info(:gen_foo, foo: :any)
+      $__behavior_info__.values.first.should == {foo: :any}
+    end
+  end
+
+  context 'behavior/1' do
+
+    it 'raises an exception if the behavior has not been defined' do
+      lambda {
+        Class.new{
+          behavior(:gen_foo)
+        }
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'can be called multiple times for one class' do
+      behavior_info(:gen_foo, foo: 0)
+      behavior_info(:gen_bar, bar: 0)
+
+      lambda {
+        Class.new{
+          behavior(:gen_foo)
+          behavior(:gen_bar)
+        }
+      }.should_not raise_error
+    end
+  end
+
+  context 'behavior check on object creation' do
+
+    it 'raises an exception when one or more function definitions are missing' do
+      behavior_info(:gen_foo, foo: 0, bar: 1)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo() nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'raises an exception when one or more functions do not have proper arity' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo(broken) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'accepts any arity when function arity is set to :any' do
+      behavior_info(:gen_foo, foo: :any)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo(first) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should_not raise_error(ArgumentError)
+    end
+
+    it 'creates the object when function definitions match' do
+      behavior_info(:gen_foo, foo: 0, bar: 1)
+      clazz = Class.new {
+        behavior(:gen_foo)
+        def foo() nil; end
+        def bar(first) nil; end
+      }
+
+      lambda {
+        clazz.new
+      }.should_not raise_error(ArgumentError)
+    end
+  end
+
+  context '#behaves_as?' do
+
+    it 'returns true when the behavior is fully suported' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new {
+        def foo() nil; end
+        def bar(first) nil; end
+        def baz(first, second) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'accepts any arity when function arity is set to :any' do
+      behavior_info(:gen_foo, foo: :any)
+      clazz = Class.new {
+        def foo(*args, &block) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'returns false when the behavior is partially supported' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new {
+        def foo() nil; end
+        def bar(first) nil; end
+      }
+
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'returns false when the behavior is not supported at all' do
+      behavior_info(:gen_foo, foo: 0, bar: 1, baz: 2)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'returns false when the behavior does not exist' do
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_false
+    end
+
+    it 'accepts behavior name as a symbol' do
+      behavior_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'accepts behavior name as a string' do
+      behavior_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?('gen_foo').should be_true
+    end
+  end
+
+  context 'aliases' do
+
+    it 'aliases behaviour_info for behavior_info' do
+      behaviour_info(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases interface for behavior_info' do
+      interface(:gen_foo)
+      clazz = Class.new { }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases behaviour for behavior' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behaviour(:gen_foo)
+        def foo() nil; end
+      }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+
+    it 'aliases behaves_as for behavior' do
+      behavior_info(:gen_foo, foo: 0)
+      clazz = Class.new {
+        behaves_as :gen_foo
+        def foo() nil; end
+      }
+      clazz.new.behaves_as?(:gen_foo).should be_true
+    end
+  end
+
+end