multimethod 0.0.1

data/test/.svn/text-base/multimethod_test.rb.svn-base

@@ -0,0 +1,92 @@
+require 'test_base'
+
+module Multimethod
+
+  class MethodTest < TestBase
+
+    class A < Object; end
+    class B < A; end
+    class C < Object; end
+    class D < B; end
+    class E < A; end
+
+    def setup
+      super
+    end
+    
+    def test_score
+      # Make some argument lists.
+      types = [ A, B, C, D, E ]
+      a = { }
+      c = { }
+      types.each do |t1|
+        n1 = t1.name.clone
+        n1.sub!(/^.*::/, '')
+        n1 = n1[0..0]
+        types.each do |t2|
+          n2 = t2.name.clone
+          n2.sub!(/^.*::/, '')
+          n2 = n2[0..0]
+          
+          symbol = "#{n1.downcase}_#{n2.downcase}".intern
+          a[symbol] = [ 1, t1.new, t2.new ]
+          c[symbol] = a[symbol].collect{|x| x.class}
+        end
+      end
+                 
+      rs = Parameter::RESTARG_SCORE
+
+      assert_not_nil m1 = Method.new(Object, :m, [ A, :x, A, :y ])
+      assert_equal 3, m1.min_args
+      assert_equal 3, m1.max_args
+
+      assert_not_nil m2 = Method.new(Object, :m, [ B, :x, A, :y ])
+      assert_equal 3, m2.min_args
+      assert_equal 3, m2.max_args
+
+      assert_not_nil m3 = Method.new(Object, :m, [ C, :x,    '*rest' ])
+      assert_equal 2, m3.min_args
+      assert_equal nil, m3.max_args
+      assert_not_nil m3.restarg
+
+      assert_not_nil m4 = Method.new(Object, :m, [ D, :x,    :y ])
+      assert_equal 3, m4.min_args
+      assert_equal 3, m4.max_args
+
+      assert_not_nil m5 = Method.new(Object, :m, [ E, :y,    :y ])
+      assert_equal 3, m4.min_args
+      assert_equal 3, m4.max_args
+      
+      # 5 == 1.class.ancestors.index(Object)
+      assert_equal [ 5, 0, 0 ]   , m1.score(c[:a_a])
+      assert_equal [ 5, 0, 1 ]   , m1.score(c[:a_b])
+      assert_equal nil           , m1.score(c[:a_c])
+      assert_equal [ 5, 1, 1 ]   , m1.score(c[:b_b])
+      assert_equal nil           , m1.score(c[:c_a])
+      assert_equal [ 5, 1, 2 ]   , m1.score(c[:b_d])
+
+      assert_equal nil           , m3.score(c[:a_a])
+      assert_equal nil           , m3.score(c[:a_b])
+      assert_equal nil           , m3.score(c[:b_b])
+      assert_equal [ 5, 0, rs ]  , m3.score(c[:c_a])
+      assert_equal [ 5, 0, rs ]  , m3.score(c[:c_c])
+
+      # Create a multimethod for later.
+      assert_not_nil mm = Multimethod.new(:test)
+      mm.add_method(m1)
+      mm.add_method(m2)
+      mm.add_method(m3)
+      mm.add_method(m4)
+
+      # Check method lookup.
+      assert_equal m1         , mm.lookup_method_(c[:a_a])
+      assert_equal m2         , mm.lookup_method_(c[:b_a])
+      assert_equal m2         , mm.lookup_method_(c[:b_b])
+
+      mm
+    end
+
+  end # class
+    
+end # module
+  

data/test/.svn/text-base/parameter_test.rb.svn-base

@@ -0,0 +1,31 @@
+require 'test_base'
+
+module Multimethod
+
+  class ParameterTest < TestBase
+
+    class A < Object; end
+    class B < A; end
+    class C < Object; end
+    class D < B; end
+
+    def setup
+      super
+    end
+    
+    def test_score
+      pA = Parameter.new(:a, A)
+      assert_equal 0,   pA.score(A)
+      assert_equal 1,   pA.score(B)
+      assert_equal nil, pA.score(C)
+      assert_equal 2,   pA.score(D)
+
+      pB = Parameter.new(:b, B)
+      assert_equal nil, pB.score(A)
+      assert_equal 0,   pB.score(B)
+      assert_equal nil, pB.score(C)
+      assert_equal 1,   pB.score(D)
+    end
+  end # class
+  
+end # module

data/test/.svn/text-base/test_base.rb.svn-base

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'multimethod'
+
+module Multimethod
+
+  class TestBase < Test::Unit::TestCase
+    def setup
+      super
+    end
+    
+    # Avoid "No test were specified" error.
+    def test_foo
+      assert true
+    end
+    
+    # Helpers.
+    def assert_equal_float(x, y, eps = 1.0e-8)
+      d = (x * eps).abs
+      assert (x - d) <= y
+      assert y <= (x + d)
+    end
+    
+  end # class
+
+end # module

data/test/.svn/text-base/usage_test.rb.svn-base

@@ -0,0 +1,146 @@
+require 'test_base'
+
+
+class A < Object
+  multimethod %q{
+def foo(x)
+  x = "A#foo(x) : (#{x.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def foo(A x)
+  x = "A#foo(A x) : (#{x.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def foo(B x)
+  x = "A#foo(B x) : (#{x.class.name})"
+  x
+end
+}
+
+end
+
+class B < A
+  multimethod %q{
+def foo(B x)
+  x = "B#foo(B x) : (#{x.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def foo(Comparable x)
+  x = "B#foo(Comparable x) : (#{x.class.name})"
+  x
+end
+}
+
+
+end
+
+class C < Object
+  include Comparable
+end
+
+class D < B
+  # Variadic
+  multimethod %q{
+def bar(x)
+  x = "D#bar(x) : (#{x.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def bar(*rest)
+  x = "D#bar(*rest) : (#{rest.inspect})"
+  x
+end
+}
+
+  multimethod %q{
+def bar(x, y)
+  x = "D#bar(x, y) : (#{x.class.name}, #{y.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def bar(x, y, A a)
+  x = "D#bar(x, y, A a) : (#{x.class.name}, #{y.class.name}, #{a.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def bar(x, y, *rest)
+  x = "D#bar(x, y, *rest) : (#{x.class.name}, #{y.class.name}, #{rest.inspect})"
+  x
+end
+}
+
+end # class D
+
+class E < A
+end
+
+
+module Multimethod
+
+  class UsageTest < TestBase
+
+    def setup
+      super
+    end
+    
+    def test_call
+      a = A.new
+      b = B.new
+      c = C.new
+      d = D.new
+      e = E.new
+
+      assert_equal 'A#foo(x) : (Fixnum)' , a.foo(1)
+      assert_equal 'A#foo(A x) : (A)'    , a.foo(a)
+      assert_equal 'A#foo(B x) : (B)'    , a.foo(b)
+      assert_equal 'A#foo(x) : (C)'      , a.foo(c)
+      assert_equal 'A#foo(B x) : (D)'    , a.foo(d)
+      assert_equal 'A#foo(A x) : (E)'    , a.foo(e)
+
+      assert_equal 'A#foo(x) : (Symbol)' , b.foo(:x)
+      assert_equal 'B#foo(Comparable x) : (Fixnum)' , b.foo(1)
+      assert_equal 'A#foo(A x) : (A)'    , b.foo(a)
+      assert_equal 'B#foo(B x) : (B)'    , b.foo(b)
+      assert_equal 'B#foo(Comparable x) : (C)'      , b.foo(c)
+      assert_equal 'B#foo(B x) : (D)'    , b.foo(d)
+      assert_equal 'A#foo(A x) : (E)'    , b.foo(e)
+    end
+
+    def test_variadic
+      a = A.new
+      d = D.new
+
+      assert_equal 'D#bar(*rest) : ([])',
+        d.bar()
+
+      assert_equal 'D#bar(x) : (Fixnum)',
+        d.bar(1)
+
+      assert_equal 'D#bar(x, y) : (Fixnum, String)' ,   
+        d.bar(1, 'a')
+
+      assert_equal 'D#bar(x, y, A a) : (Fixnum, String, A)' , 
+        d.bar(1, 'a', a)
+
+      assert_equal 'D#bar(x, y, *rest) : (Fixnum, String, [3])' , 
+        d.bar(1, 'a', 3)
+    end
+
+  end # class
+  
+end # module

data/test/method_test.rb

@@ -0,0 +1,89 @@
+require 'test_base'
+
+module Multimethod
+
+  class MethodTest < TestBase
+
+    class A < Object; end
+    class B < A; end
+    class C < Object; end
+    class D < B; end
+
+    def setup
+      super
+    end
+    
+    def test_scan_parameter
+      assert_not_nil m1 = Method.new(Object, :m, [ A, :a, B, :b, :c, '*d' ])
+
+      assert_equal 5, m1.parameter.size
+
+      i = -1
+      
+      i = i + 1
+      assert_equal :self,  m1.parameter[i].name
+      assert_equal Object, m1.parameter[i].type
+      assert       !       m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :a, m1.parameter[i].name
+      assert_equal A, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :b, m1.parameter[i].name
+      assert_equal B, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :c, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :d, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       m1.parameter[i].restarg
+
+      m1
+    end
+
+    def test_scan_parameter_string
+      assert_not_nil m1 = Method.new(Object, :m, 'A a, B b, c = nil, *d')
+
+      assert_equal 5, m1.parameter.size
+      
+      i = -1
+
+      i = i + 1
+      assert_equal :self, m1.parameter[i].name
+      assert_equal Object, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :a, m1.parameter[i].name
+      assert_equal 'A', m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :b, m1.parameter[i].name
+      assert_equal 'B', m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :c, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+
+      i = i + 1
+      assert_equal :d, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       m1.parameter[i].restarg
+
+      m1
+    end
+
+  end # class
+    
+end # module
+  

data/test/multimethod_test.rb

@@ -0,0 +1,92 @@
+require 'test_base'
+
+module Multimethod
+
+  class MethodTest < TestBase
+
+    class A < Object; end
+    class B < A; end
+    class C < Object; end
+    class D < B; end
+    class E < A; end
+
+    def setup
+      super
+    end
+    
+    def test_score
+      # Make some argument lists.
+      types = [ A, B, C, D, E ]
+      a = { }
+      c = { }
+      types.each do |t1|
+        n1 = t1.name.clone
+        n1.sub!(/^.*::/, '')
+        n1 = n1[0..0]
+        types.each do |t2|
+          n2 = t2.name.clone
+          n2.sub!(/^.*::/, '')
+          n2 = n2[0..0]
+          
+          symbol = "#{n1.downcase}_#{n2.downcase}".intern
+          a[symbol] = [ 1, t1.new, t2.new ]
+          c[symbol] = a[symbol].collect{|x| x.class}
+        end
+      end
+                 
+      rs = Parameter::RESTARG_SCORE
+
+      assert_not_nil m1 = Method.new(Object, :m, [ A, :x, A, :y ])
+      assert_equal 3, m1.min_args
+      assert_equal 3, m1.max_args
+
+      assert_not_nil m2 = Method.new(Object, :m, [ B, :x, A, :y ])
+      assert_equal 3, m2.min_args
+      assert_equal 3, m2.max_args
+
+      assert_not_nil m3 = Method.new(Object, :m, [ C, :x,    '*rest' ])
+      assert_equal 2, m3.min_args
+      assert_equal nil, m3.max_args
+      assert_not_nil m3.restarg
+
+      assert_not_nil m4 = Method.new(Object, :m, [ D, :x,    :y ])
+      assert_equal 3, m4.min_args
+      assert_equal 3, m4.max_args
+
+      assert_not_nil m5 = Method.new(Object, :m, [ E, :y,    :y ])
+      assert_equal 3, m4.min_args
+      assert_equal 3, m4.max_args
+      
+      # 5 == 1.class.ancestors.index(Object)
+      assert_equal [ 5, 0, 0 ]   , m1.score(c[:a_a])
+      assert_equal [ 5, 0, 1 ]   , m1.score(c[:a_b])
+      assert_equal nil           , m1.score(c[:a_c])
+      assert_equal [ 5, 1, 1 ]   , m1.score(c[:b_b])
+      assert_equal nil           , m1.score(c[:c_a])
+      assert_equal [ 5, 1, 2 ]   , m1.score(c[:b_d])
+
+      assert_equal nil           , m3.score(c[:a_a])
+      assert_equal nil           , m3.score(c[:a_b])
+      assert_equal nil           , m3.score(c[:b_b])
+      assert_equal [ 5, 0, rs ]  , m3.score(c[:c_a])
+      assert_equal [ 5, 0, rs ]  , m3.score(c[:c_c])
+
+      # Create a multimethod for later.
+      assert_not_nil mm = Multimethod.new(:test)
+      mm.add_method(m1)
+      mm.add_method(m2)
+      mm.add_method(m3)
+      mm.add_method(m4)
+
+      # Check method lookup.
+      assert_equal m1         , mm.lookup_method_(c[:a_a])
+      assert_equal m2         , mm.lookup_method_(c[:b_a])
+      assert_equal m2         , mm.lookup_method_(c[:b_b])
+
+      mm
+    end
+
+  end # class
+    
+end # module
+