multimethod 0.0.1 → 0.1.0

data/lib/multimethod/table.rb

@@ -10,8 +10,10 @@ module Multimethod
 
     @@hook_var = :@@__multimethods
  
+    attr_accessor :method
     def initialize(*opts)
-      @method = { }
+      @multimethod_by_name = { }
+      @multimethod = [ ]
 
       # Type name lookup cache
       @name_to_object = { }
@@ -21,33 +23,74 @@ module Multimethod
     @@match_def = /^\s*def\s+(\w+)([(](.*)[)])?/
     # Interface to Multimethod::Module mixin multimethod
     def install_method(mod, body, file = nil, line = nil)
-      name = nil
-      params = nil
-
-      # Parse first line.
-      if md = body.match(@@match_def)
-        name = md[1]
-        params = md[3] || ''
-      else
-        raise("Cannot determine name(params) from body")
-      end
-        
+      file ||= __FILE__
+      line ||= __LINE__
+      verbose = nil
+      #if body =~ /def bar\(x, y\)/
+      #  verbose = 1
+      #end
+
+      # Parse the signature from the method body
+      signature = Signature.new
+      signature.mod = mod
+      signature.verbose = verbose
+      signature.file = file
+      signature.line = line
+      new_body = signature.scan_string(body.clone)
+      
       # Get our Multimethod for this
-      mm = lookup_multimethod(name)
+      mm = lookup_multimethod(signature.name)
       mm.install_dispatch(mod)
-      m = mm.new_method(mod, params)
- 
-      # Evaluate our method.
-      new_body = body.clone
-      new_body.sub!(@@match_def, m.to_ruby)
+      m = mm.new_method_from_signature(signature)
+
+      # Replace the multimethod signature with a plain Ruby signature.
+      new_body = m.to_ruby_def + new_body
+
+      #if true || m.signature.restarg
+      #   $stderr.puts "install_method(#{mod}) => #{m.to_ruby_signature}:\n#{new_body}"
+      #end
+
+      # Evaluate the new method body.     
+      mod.module_eval(new_body, file, line)
+    end
+
+
+    def find_multimethod(x)
+      case x
+      when String
+        signature = Signature.new(:string => x)
+        when Method
+        signature = x.signature
+      end
+
+      x = @multimethod.select{|mm| mm.matches_signature(signature)}
+
+      x
+    end
+
 
-      # if m.restarg
-      #   $stderr.puts "install_method(#{mod}) => #{m.to_ruby}:\n#{new_body}"
-      # end
+    def find_method(x)
+      case x
+      when String
+        signature = Signature.new(:string => x)
+      when Method
+        signature = x.signature
+      end
+
+      x = @multimethod.select{|mm| mm.matches_signature(signature)}
+      # $stderr.puts "find_method(#{x}) => #{x.inspect}"
+      x = x.collect{|mm| mm.find_method(signature)}.flatten
 
-      file ||= __FILE__; line ||= __LINE__
-      m.file = file; m.line = line
-      mod.module_eval(new_body, file || __FILE__, line || __LINE__)
+      # $stderr.puts "find_method(#{x}) => #{x.inspect}"
+      x
+    end
+
+
+    def remove_method(signature)
+      x = find_method(signature)
+      raise("Found #{x.size} multimethods: #{x.inspect}") if x.size > 1
+      x = x[0]
+      x.multimethod.remove_method(x)
     end
 
 
@@ -55,10 +98,11 @@ module Multimethod
       name = name.to_s
 
       # THREAD CRITICAL BEGIN
-      unless mm = @method[name]
+      unless mm = @multimethod_by_name[name]
         mm = Multimethod.new(name)
         mm.table = self
-        @method[name] = mm
+        @multimethod_by_name[name] = mm
+        @multimethod << mm
       end
       # THREAD CRITICAL END
 
@@ -68,7 +112,7 @@ module Multimethod
 
     # Interface to code generated by #install_dispatch.
     def dispatch(name, rcvr, args)
-      unless mm = @method[name]
+      unless mm = @multimethod_by_name[name]
         raise NameError, 'No method for multmethod #{name}' unless mm
       end
       mm.dispatch(rcvr, args)
@@ -79,15 +123,16 @@ module Multimethod
     # Support
     #
 
-    def name_to_object(name, scope = nil, method = nil)
+    def name_to_object(name, scope = nil, file = nil, line = nil)
       scope ||= Kernel
-      # THREAD CRITICAL
+      # THREAD CRITICAL BEGIN
       unless x = (@name_to_object[scope] ||= { })[name]
         # $stderr.puts " name_to_object(#{name.inspect}) in #{scope}"
         x = 
           @name_to_object[scope][name] = 
-          scope.module_eval(name, method ? method.file : __FILE__, method ? method.line : __LINE__)
+          scope.module_eval(name, file || __FILE__, line || __LINE__)
       end
+      # THREAD CRITICAL END
 
       x
     end

data/test/add_remove_test.rb

@@ -0,0 +1,99 @@
+require 'test_base'
+
+
+class AddRemoveA < Object
+end
+
+module Multimethod
+
+  class AddRemoveTest < TestBase
+
+    def setup
+      super
+
+      AddRemoveA.class_eval {
+  multimethod %q{
+def asdfwert(x)
+  x = "A#asdfwert(x) : (#{x.class.name})"
+  x
+end
+}
+
+  multimethod %q{
+def asdfwert(AddRemoveA x)
+  x = "A#asdfwert(A x) : (#{x.class.name})"
+  x
+end
+}
+
+      }
+
+    end
+    
+
+    def test_find_multimethod
+      assert_not_nil mm = Table.instance.find_multimethod("AddRemoveA#asdfwert(x)")
+      assert 1, mm.size 
+      mm = mm[0]
+      assert_not_nil mm
+      assert_equal 'asdfwert', mm.name
+
+      mm
+    end
+
+
+    def test_remove
+      # Check method counts
+      assert_method_count(2)
+
+      # Remove asdfwert(AddRemoveA x)
+      assert_not_nil m = Table.instance.find_method("AddRemoveA#asdfwert(AddRemoveA x)")
+      assert 1, m.size 
+      m = m[0]
+      assert_not_nil m
+      assert_not_nil mm = m.multimethod
+      assert_equal   'AddRemoveA#asdfwert(AddRemoveA x)', m.signature.to_s
+      assert_equal   AddRemoveA, m.signature.mod
+      assert_equal   AddRemoveA, m.signature.parameter[1].type_object
+
+      AddRemoveA.remove_multimethod(m)
+  
+      assert_not_nil m = Table.instance.find_method("AddRemoveA#asdfwert(AddRemoveA x)")
+      assert 0, m.size 
+
+      assert_method_count(1)
+
+      # Remove asdfwert(x)
+      assert_not_nil m = Table.instance.find_method("AddRemoveA#asdfwert(x)")
+      assert 1, m.size 
+      m = m[0]
+      assert_not_nil m
+      assert_not_nil mm = m.multimethod
+      assert_equal   'AddRemoveA#asdfwert(Kernel x)', m.signature.to_s
+      assert_equal   AddRemoveA, m.signature.mod
+      assert_equal   Kernel, m.signature.parameter[1].type_object
+
+      AddRemoveA.remove_multimethod(m)
+
+      assert_not_nil m = Table.instance.find_method("AddRemoveA#asdfwert(x)")
+      assert 0, m.size 
+
+      assert_method_count(1, 0)
+    end
+
+
+    def assert_method_count(impl, dispatch = 1)
+      mm = test_find_multimethod
+
+      methods = AddRemoveA.instance_methods(false).select{|x| x =~ /\d_asdfwert$/}
+      assert impl, methods.size 
+      assert impl, mm.method.size
+      
+      methods = AddRemoveA.instance_methods(false).select{|x| x = 'asdfwert'}
+      assert dispatch, methods.size 
+    end
+
+
+  end # class
+  
+end # module

data/test/method_test.rb

@@ -13,74 +13,9 @@ module Multimethod
       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
+    def test_basic
+      true
     end
 
   end # class

data/test/multimethod_test.rb

@@ -10,10 +10,12 @@ module Multimethod
     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 ]
@@ -36,26 +38,26 @@ module Multimethod
                  
       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 m1 = Method.new(:m_1, Object, :m, [ A, :x, A, :y ])
+      assert_equal 3, m1.signature.min_args
+      assert_equal 3, m1.signature.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 m2 = Method.new(:m_2, Object, :m, [ B, :x, A, :y ])
+      assert_equal 3, m2.signature.min_args
+      assert_equal 3, m2.signature.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 m3 = Method.new(:m_3, Object, :m, [ C, :x,    '*rest' ])
+      assert_equal 2, m3.signature.min_args
+      assert_equal nil, m3.signature.max_args
+      assert_not_nil    m3.signature.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 m4 = Method.new(:m_4, Object, :m, [ D, :x,    :y ])
+      assert_equal 3, m4.signature.min_args
+      assert_equal 3, m4.signature.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
+      assert_not_nil m5 = Method.new(:m_5, Object, :m, [ E, :y,    :y ])
+      assert_equal 3, m4.signature.min_args
+      assert_equal 3, m4.signature.max_args
       
       # 5 == 1.class.ancestors.index(Object)
       assert_equal [ 5, 0, 0 ]   , m1.score(c[:a_a])

data/test/signature_test.rb

@@ -0,0 +1,190 @@
+require 'test_base'
+
+module Multimethod
+
+  class SignatureTest < 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 = Signature.new(:mod => Object, 
+                                        :name => :m, 
+                                        :parameter => [ 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
+      assert       !       m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :a, m1.parameter[i].name
+      assert_equal A, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :b, m1.parameter[i].name
+      assert_equal B, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :c, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :d, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      m1
+    end
+
+
+    def assert_signature(m1)
+      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
+      assert       !       m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :a, m1.parameter[i].name
+      assert_equal 'A', m1.parameter[i].type
+      assert       !  m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      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
+      assert_equal 'nil', m1.parameter[i].default
+
+      i = i + 1
+      assert_equal :d, m1.parameter[i].name
+      assert_equal Kernel, m1.parameter[i].type
+      assert       m1.parameter[i].restarg
+      assert       !       m1.parameter[i].default
+
+      m1
+    end
+
+
+    def test_scan_parameter_string
+      assert_not_nil m1 = Signature.new(:mod => Object, :name => :m, :parameter => 'A a, B b, c = nil, *d')
+      assert_signature m1
+      assert ! m1.class_method
+    end
+
+
+    def test_scan_string
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+
+      assert_signature m1
+      assert ! m1.class_method
+    end
+
+
+    def test_scan_string_2
+      assert_not_nil m1 = Signature.new(:string => 'Object def m(A a, B b, c = nil, *d)')
+
+      assert_signature m1
+      assert ! m1.class_method
+    end
+
+
+    def test_scan_string_class_method
+      assert_not_nil m1 = Signature.new(:string => 'Object.m(A a, B b, c = nil, *d)')
+
+      assert_signature m1
+      assert m1.class_method
+    end
+
+
+    def test_scan_string_class_method_2
+      assert_not_nil m1 = Signature.new(:string => 'Object def self.m(A a, B b, c = nil, *d)')
+
+      assert_signature m1
+      assert m1.class_method
+    end
+
+
+    def test_scan_string_balanced_parens
+      assert_not_nil m1 = Signature.new(:string => 'Object.m(A a, B b = call_method(foo(bar, "45,67"), \',\'), c = nil, *d)')
+
+      assert_signature m1
+      assert           m1.class_method
+      assert_equal     :b, m1.parameter[2].name
+      assert           m1.parameter[2].default
+      assert_equal     'call_method(foo(bar, "45,67"), \',\')', m1.parameter[2].default
+    end
+
+    def test_scan_default_at_end
+      assert_not_nil m1 = Signature.new(:string => 'Object.m(A a, B b = call_method(foo(bar, "45,67"), \',\'), c = nil)')
+
+      assert           m1.class_method
+      assert_equal     :c, m1.parameter[3].name
+      assert           m1.parameter[3].default
+      assert_equal     'nil', m1.parameter[3].default
+    end
+
+
+    def test_cmp
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+      assert_not_nil m2 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+
+      assert       m1 == m2
+
+
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+      assert_not_nil m2 = Signature.new(:string => 'Object#x(A a, B b, c = nil, *d)')
+
+      assert       m1 != m2
+
+
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+      assert_not_nil m2 = Signature.new(:string => 'Object#m(A q, B x, c = nil, *args)')
+
+      assert       m1 == m2
+
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+      assert_not_nil m2 = Signature.new(:string => 'Object#m(A q, B x, c = nil, d)')
+
+      assert       m1 != m2
+
+      assert_not_nil m1 = Signature.new(:string => 'Object#m(A a, B b, c = nil, *d)')
+      assert_not_nil m2 = Signature.new(:string => 'Object#m(A q, B x, c = nil)')
+
+      assert       m1 != m2
+     end
+
+  end # class
+    
+end # module
+