multimethod 0.0.1

data/lib/multimethod/.svn/text-base/multimethod.rb.svn-base

@@ -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/.svn/text-base/parameter.rb.svn-base

@@ -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/.svn/text-base/table.rb.svn-base

@@ -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/lib/multimethod/core_extensions.rb

@@ -0,0 +1,38 @@
+module Multimethod
+
+  module ObjectExtension
+    def self.append_features(base) # :nodoc:
+      # puts "append_features{#{base}}"
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def multimethod(body, file = nil, line = nil)
+        unless file && line
+          fileline = caller(1)[0]
+          if fileline && md = /^(.*):(\d+)$/.match(fileline)
+            file, line = md[1], md[2].to_i
+            
+            newlines = 0
+            body.gsub(/\n/s){|x| newlines = newlines + 1}
+            line -= newlines
+          end
+          
+          # $stderr.puts "file = #{file.inspect}, line = #{line.inspect}"
+        end
+        
+        ::Multimethod::Table.instance.install_method(self, body, file, line)
+      end
+    end
+  end # class
+end # module
+
+
+# Add to Module
+Object.class_eval do
+  include Multimethod::ObjectExtension
+end
+
+
+

data/lib/multimethod/method.rb

@@ -0,0 +1,232 @@
+module Multimethod
+
+  class Method
+    attr_accessor :mod
+    attr_accessor :name
+    attr_accessor :parameter
+
+    attr_accessor :min_args
+    attr_accessor :max_args
+    attr_accessor :restarg
+    attr_accessor :default
+
+    attr_accessor :multimethod
+    attr_accessor :file
+    attr_accessor :line
+
+    def initialize(mod, name, params)
+      raise NameError, "multimethod method name not specified" unless name && name.to_s.size > 0
+
+      name = Multimethod.normalize_name(name)
+
+      @mod = mod
+      @name = name
+      @parameter = [ ]
+      @min_args = 0
+      @max_args = 0
+      @restarg = nil
+      @default = nil
+
+      @score = { }
+
+      # Add self parameter at front.
+      add_parameter(Parameter.new('self', mod))
+
+      # Handle other parameters.
+      case params
+      when Array
+        scan_parameters(params)
+      when String
+        scan_parameters_string(params)
+      end
+    end
+    
+
+    # For sort
+    def <=>(x)
+      0
+    end
+
+
+    def scan_parameters_string(params)
+
+      #$stderr.puts "scan_parameters_string(#{params.inspect})"
+
+      str = params.clone
+
+      until str.empty?
+        name = nil
+        type = nil
+        default = nil
+        
+        str.sub!(/^\s+/, '')
+
+        # $stderr.puts "  str=#{str.inspect}"
+        
+        if md = /^(\w+(::\w+)*)\s+(\w+)/i.match(str)
+          str = md.post_match
+          type = md[1]
+          name = md[3]
+        elsif md = /^(\*?\w+)/i.match(str)
+          str = md.post_match
+          type = nil
+          name = md[1]
+        else
+          raise NameError, "Syntax error in multimethod parameters: #{params.inspect} before #{str.inspect}"
+        end
+        
+        if md = /^\s*=\s*([^,]+)/.match(str)
+          str = md.post_match
+          default = md[1]
+        end
+        
+        
+        str.sub!(/^\s+/, '')
+        if ! str.empty? 
+          if md = /^,/.match(str)
+            str = md.post_match
+          else
+            raise NameError, "Syntax error in multimethod parameters: expected ',' before #{str.inspect}"
+          end
+        end
+        
+        p = Parameter.new(name, type, default)
+        add_parameter(p)
+      end
+    end
+
+
+    def scan_parameters(params)
+      until params.empty?
+        name = nil
+        type = nil
+        restarg = false
+        default = nil
+        
+        if x = params.shift
+          case x
+          when Class
+            type = x
+          else
+            name = x
+          end
+        end
+
+        if ! name && (x = params.shift)
+          name = x
+        end
+
+        raise("Parameter name expected, found #{name.inspect}") unless name.kind_of?(String) || name.kind_of?(Symbol)
+        raise("Parameter type expected, found #{type.inspect}") unless type.kind_of?(Module) || type.nil?
+
+        p = Parameter.new(name, type, default)
+        add_parameter(p)
+      end
+
+    end
+    
+    def add_parameter(p)
+      if p.restarg
+        raise("Too many restargs") if @restarg
+        @restarg = p
+        @max_args = nil
+      end
+      if p.default
+        (@default ||= [ ]).push(p)
+      end
+
+      p.i = @parameter.size
+      @parameter.push(p)
+      p.method = self
+
+      unless p.default || p.restarg
+        @min_args = @parameter.size
+      end
+
+      unless @restarg
+        @max_args = @parameter.size
+      end
+    end
+
+
+    def score_cached(args)
+      unless x = @score[args]
+        x = @score[args] =
+          score(args)
+      end
+      x
+    end
+
+
+    def score(args)
+      
+      if @min_args > args.size
+        # Not enough args
+        score = nil
+      elsif @max_args && @max_args < args.size
+        # Too many args?
+        # $stderr.puts "max_args = #{@max_args}, args.size = #{args.size}"
+        score = nil
+      else
+        # Interpret how close the argument type is to the parameter's type.
+        i = -1
+        score = args.collect{|a| parameter_at(i = i + 1).score(a)}
+
+        # Handle score for trailing restargs.
+        if @restarg || @default
+          while (i = i + 1) < @parameter.size
+            # $stderr.puts "  Adding score i=#{i}"
+            score << parameter_at(i).score(NilClass)
+          end
+        end
+
+        # If any argument cannot match, avoid this method.
+        score = nil if score.index(nil)
+      end
+
+      # if true || @name =~ /_bar$/
+      #   $stderr.puts "    Method: score #{self.to_s} #{args.inspect} => #{score.inspect}"
+      # end
+
+      score
+    end
+    
+
+    def parameter_at(i)
+      if i >= @parameter.size && @restarg
+        @restarg
+      else
+        @parameter[i]
+      end
+    end
+
+ 
+    def parameter_to_s(p = nil)
+      p ||= @parameter
+      p.collect{|x| x.to_s_long}.join(', ')
+    end
+
+    def to_s(name = nil)
+      name ||= @name
+      p = @parameter.clone
+      rcvr = p.shift
+      "#{rcvr.type.name}##{name}(#{parameter_to_s(p)})"
+    end
+
+    def to_ruby
+      "def #{name}(#{to_s_arg})"
+    end
+
+    def to_s_arg
+      x = @parameter.clone
+      x.shift
+      x.collect{|x| x.to_ruby}.join(', ')
+    end
+
+    def inspect
+      to_s
+    end
+  end # class
+end # module
+
+