multimethod 0.0.1

data/lib/multimethod/multimethod.rb

@@ -0,0 +1,171 @@
+module Multimethod
+  class Multimethod
+
+    attr_accessor :name
+    attr_accessor :method
+    attr_accessor :table
+
+    def initialize(name, *opts)
+      raise NameError, "multimethod name not specified" unless name && name.to_s.size > 0
+ 
+      @name = name
+      @name_i = 0
+      @method = [ ]
+      @dispatch = { }
+
+      @lookup_method = { }
+    end
+
+
+    def gensym(name = nil)
+      name ||= @name
+      "_multimethod_#{@name_i = @name_i + 1}_#{name}"
+    end
+
+
+    def new_method(mod, *args)
+      m = Method.new(mod, gensym, *args)
+      add_method(m)
+      m
+    end
+
+
+    def add_method(method)
+      # THREAD CRITICAL BEGIN
+      @method.push(method)
+      method.multimethod = self
+      @lookup_method = { } # flush cache
+      # THREAD CRITICAL END
+    end
+
+
+    def dispatch(rcvr, args)
+      apply_method(lookup_method(rcvr, args), rcvr, args)
+    end
+
+
+    # Interface to Multimethod::Table
+    def apply_method(meth, rcvr, args)
+      unless meth # && false
+        $stderr.puts "Available multimethods for #{rcvr.class.name}##{@name}(#{args}):"
+        $stderr.puts "  " + @method.sort{|a,b| a.min_args <=> b.min_args }.collect{|x| x.to_s(name)}.join("\n  ")
+        $stderr.puts "\n"
+      end
+      raise NameError, "Cannot find multimethod for #{rcvr.class.name}##{@name}(#{args})" unless meth
+      rcvr.send(meth.name, *args)
+    end
+
+
+    def lookup_method(rcvr, args)
+      args = args.clone
+      args.unshift(rcvr)
+      lookup_method_cached_(args)
+    end
+
+
+    def lookup_method_cached_(args)
+      args_type = args.collect{|x| x.class}
+
+      # THREAD CRITICAL BEGIN
+      unless result = @lookup_method[args_type]
+        result = @lookup_method[args_type] =
+          lookup_method_(args_type)
+      end
+      # THREAD CRITICAL END
+
+      result
+    end
+
+
+    def lookup_method_(args)
+      scores = score_methods(@method, args)
+      if scores.empty?
+        result = nil
+      else
+        result = scores[0][1]
+        raise("Ambigious method") if scores.select{|x| x[0] == result}.size > 1
+      end
+
+      #if @name.to_s == 'bar'
+      #  $stderr.puts "args = " + args.collect{|x| x.class.name + ' ' + x.to_s}.join(",  ")
+      #  $stderr.puts "scores:\n  " + scores.collect{|x| x.inspect}.join("\n  ")
+      # end
+
+
+      result
+    end
+
+    def score_methods(meths, args)
+      scores = meths.collect do |meth|
+        score = meth.score_cached(args)
+        if score 
+          score = [ score, meth ]
+        else
+          score = nil
+        end
+
+        score
+      end
+
+      scores.compact!
+      scores.sort!
+      
+      # $stderr.puts "score_methods(#{args.inspect}) => \n#{scores.inspect}"
+
+      scores
+    end
+
+
+    def install_dispatch(mod)
+      # THREAD CRITICAL BEGIN
+      unless @dispatch[mod]
+        @dispatch[mod] = true
+        # $stderr.puts "install_dispatch(#{name}) into #{mod}\n";
+        mod.class_eval(body = <<-"end_eval", __FILE__, __LINE__)
+def #{name}(*args)
+  ::#{table.class.name}.instance.dispatch(#{name.inspect}, self, args)
+end
+end_eval
+# $stderr.puts "install_dispatch = #{body}"
+      end
+      # THREAD CRITICAL END
+    end
+
+
+    ##################################################
+    # Support
+    #
+
+    @@name_map = {
+      '@' => 'AT',
+      '=' => 'EQ',
+      '<' => 'LT',
+      '>' => 'GT',
+      '+' => 'ADD',
+      '-' => 'SUB',
+      '*' => 'MUL',
+      '/' => 'DIV',
+      '%' => 'MOD',
+      '^' => 'XOR',
+      '|' => 'OR',
+      '&' => 'AND',
+      '!' => 'NOT',
+      '~' => 'TIL',
+      nil => nil
+    };
+    @@name_map.delete(nil)
+
+    @@name_rx = Regexp.new('(' + @@name_map.keys.collect{|x| Regexp.quote(x)}.join('|') + ')')
+
+    def self.normalize_name(name)
+      name = name.to_s.clone
+      name.sub!(@@name_rx){|x| "_#{@@name_map[x] || '_'}_"}
+
+      name.intern
+    end
+
+  end # class
+
+end # module
+
+

data/lib/multimethod/parameter.rb

@@ -0,0 +1,64 @@
+module Multimethod
+  class Parameter
+    RESTARG_SCORE = 9999
+
+    attr_accessor :name
+    attr_accessor :i
+    attr_accessor :type
+    attr_accessor :default
+    attr_accessor :restarg
+
+    attr_accessor :method
+
+    def initialize(name, type = nil, default = nil, restarg = false)
+      # $stderr.puts "initialize(#{name.inspect}, #{type}, #{restarg.inspect})"
+      name = name.to_s
+      if name.sub!(/^\*/, '')
+        restarg = true
+      end  
+
+      name = name.intern unless name.kind_of?(Symbol)
+      @name = name
+      @i = nil
+      @type = type || Kernel
+      @default = default
+      @restarg = restarg
+    end
+
+
+    def score(arg)
+      return RESTARG_SCORE if @restarg
+      score = all_types(arg).index(type_object)
+    end
+
+
+    def all_types(arg)
+      arg.ancestors
+    end
+
+
+    def type_object
+      if @type.kind_of?(String)
+        @type = @method.multimethod.table.name_to_object(@type, @method.mod, @method)
+      end
+      @type
+    end
+
+
+    def to_s
+      @restarg ? "*#{@name}" : @name
+    end
+
+
+    def to_s_long
+      "#{@type} #{to_ruby}"
+    end
+
+
+    def to_ruby
+      "#{to_s}#{@default ? ' = ' + @default : ''}"
+    end
+
+  end # class
+end # module
+

data/lib/multimethod/table.rb

@@ -0,0 +1,99 @@
+module Multimethod
+  class Table
+
+    @@instance = nil
+    def self.instance
+      # THREAD CRITICAL BEGIN
+      @@instance ||= self.new
+      # TRREAD CRITICAL END
+    end
+
+    @@hook_var = :@@__multimethods
+ 
+    def initialize(*opts)
+      @method = { }
+
+      # Type name lookup cache
+      @name_to_object = { }
+    end
+
+
+    @@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
+        
+      # Get our Multimethod for this
+      mm = lookup_multimethod(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)
+
+      # if m.restarg
+      #   $stderr.puts "install_method(#{mod}) => #{m.to_ruby}:\n#{new_body}"
+      # end
+
+      file ||= __FILE__; line ||= __LINE__
+      m.file = file; m.line = line
+      mod.module_eval(new_body, file || __FILE__, line || __LINE__)
+    end
+
+
+    def lookup_multimethod(name)
+      name = name.to_s
+
+      # THREAD CRITICAL BEGIN
+      unless mm = @method[name]
+        mm = Multimethod.new(name)
+        mm.table = self
+        @method[name] = mm
+      end
+      # THREAD CRITICAL END
+
+      mm
+    end
+
+
+    # Interface to code generated by #install_dispatch.
+    def dispatch(name, rcvr, args)
+      unless mm = @method[name]
+        raise NameError, 'No method for multmethod #{name}' unless mm
+      end
+      mm.dispatch(rcvr, args)
+    end
+
+
+    #################################################
+    # Support
+    #
+
+    def name_to_object(name, scope = nil, method = nil)
+      scope ||= Kernel
+      # THREAD CRITICAL
+      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__)
+      end
+
+      x
+    end
+
+  end # class
+
+end # module
+
+

data/test/.svn/README.txt

@@ -0,0 +1,2 @@
+This is a Subversion working copy administrative directory.
+Visit http://subversion.tigris.org/ for more information.

data/test/.svn/entries

@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<wc-entries
+   xmlns="svn:">
+<entry
+   committed-rev="3"
+   name=""
+   committed-date="2006-11-21T15:59:22.761488Z"
+   url="svn+ssh://rubyforge.org/var/svn/multimethod/multimethod/trunk/test"
+   last-author="kstephens"
+   kind="dir"
+   repos="svn+ssh://rubyforge.org/var/svn/multimethod"
+   revision="3"/>
+<entry
+   committed-rev="3"
+   name="method_test.rb"
+   text-time="2006-11-21T05:04:48.000000Z"
+   committed-date="2006-11-21T15:59:22.761488Z"
+   checksum="40b4ca1c1c328339e7380b23522998e5"
+   last-author="kstephens"
+   kind="file"/>
+<entry
+   committed-rev="3"
+   name="parameter_test.rb"
+   text-time="2006-11-21T07:25:08.000000Z"
+   committed-date="2006-11-21T15:59:22.761488Z"
+   checksum="6893f4ec384c8ed8b5bede4642783d13"
+   last-author="kstephens"
+   kind="file"/>
+<entry
+   committed-rev="3"
+   name="usage_test.rb"
+   text-time="2006-11-21T06:51:40.000000Z"
+   committed-date="2006-11-21T15:59:22.761488Z"
+   checksum="c3b86cfd548e87f6a3abfba9b6e64c54"
+   last-author="kstephens"
+   kind="file"/>
+<entry
+   committed-rev="3"
+   name="test_base.rb"
+   text-time="2006-11-20T21:58:18.000000Z"
+   committed-date="2006-11-21T15:59:22.761488Z"
+   checksum="52aa7dfea864715aede8ab3e5aba1ca0"
+   last-author="kstephens"
+   kind="file"/>
+<entry
+   committed-rev="3"
+   name="multimethod_test.rb"
+   text-time="2006-11-21T07:23:21.000000Z"
+   committed-date="2006-11-21T15:59:22.761488Z"
+   checksum="4de3fbfd3e551eaecc1b9a550b08a80a"
+   last-author="kstephens"
+   kind="file"/>
+</wc-entries>

data/test/.svn/format

@@ -0,0 +1 @@
+4

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

@@ -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
+