vlx-multi 0.1

data/sample.rb

@@ -0,0 +1,148 @@
+require 'vlx_multi'
+
+test_global = true
+test_module = true
+
+
+class A
+end
+
+class B < A
+end
+
+class C < A
+end
+
+class D < C
+end
+
+
+# test global functions reloading
+
+if test_global == true then
+
+  # reload by regexp
+  vlxm(:some,"$array",/<[\w;: ]+>/) do |_1,_2|
+    puts 'some<$array;Regexp>' + _1.to_s + ' ' + _2.to_s
+  end
+
+  vlxm(:some,Object,String) do |s,s1| puts 'some<Object,String> ' + s.to_s + ' ' + s1.to_s end
+
+  vlxm(:some,String) do |s| puts 'some<String> ' + s end
+
+  vlxm(:some,String,String) do |s,s1| puts 'some<String,String> ' + s + ' ' + s1 end
+
+  vlxm(:some,Object) do |o| puts 'some<Object> ' + o.inspect end
+
+  vlxm(:some,:_1,:_2) do |_,_| puts 'some<:_1,:_2> ' end
+
+  vlxm(:some,:_1) do |_| puts 'some<:_1> ' end
+
+  vlxm(:some,'nil text',nil) do |_,_| puts 'some<nil text,nil> ' end
+
+  vlxm(:some,Symbol,Symbol) do |s,s1| puts 'some<Symbol,Symbol> ' + s.to_s + ' ' + s1.to_s end
+
+  # reload by condition: _ == 'custom def'
+  vlxm(:some,vlxmd("_ == 'custom def'")) do |_| puts 'some<Def>'end
+
+  vlxm(:some,A,D) { |_,_| puts '<A:D>' }
+  vlxm(:some,B,C) { |_,_| puts '<B:C>' }
+
+
+  puts 'global test begin'
+  begin    
+    some('text')
+    some('text','text2')
+    some('nil text',nil)
+    some([55,44])
+    some(:_1,:_2)
+    some(:_1)
+    some(:_1,:_b)
+    some('$array', '<names:string; values:varaint>')
+    some(A.new,D.new)
+    some(B.new,C.new)
+    some(B.new,D.new)
+    some(D.new,D.new)
+    some('custom def')
+  rescue Exception
+    p $!
+  end
+  puts 'global test end'
+
+end
+
+
+
+# test module functions reloading
+
+if test_module == true then
+
+  module VlxTest
+  module Inner
+
+    vlxm(:some,String) do |s| puts 'VlxTest::some<String> ' + s end
+
+    vlxm(:some,String,String) do |s,s1| puts 'VlxTest::some<String,String> ' + s + ' ' + s1 end
+
+    vlxm(:some,Object) do |o| puts 'VlxTest::some<Object> ' + o.to_s end
+
+    vlxm(:some,:_1,:_2) do |_,_| puts 'VlxTest::some<:_1,:_2> ' end
+
+    vlxm(:some,:_1) do |_,_| puts 'VlxTest::some<:_1> ' end
+
+    vlxm(:some,Symbol,Symbol) do |s,s1| 
+      puts 'VlxTest::some<Symbol,Symbol> ' + s.to_s + ' ' + s1.to_s 
+    end
+
+
+    puts 'module test begin'
+    some('text')
+    some('text','text2')
+    some(55)
+    some(:_1,:_2)
+    some(:_1)
+    some(:_1,:_b)
+    puts 'module test end'
+
+    class Test
+      def initialize(name)
+        @name = name
+      end
+
+      vlxm(:some,String) do |s| 
+        puts 'VlxTest::Test::some<String> ' + s  + ' ' + @name
+      end
+
+      vlxm(:some,String,String) do |s,s1| puts 'VlxTest::Test::some<String,String> ' + s + ' ' + s1 end
+
+      vlxm(:some,Object) do |o| puts 'VlxTest::Test::some<Object> ' + o.to_s end
+
+      vlxm(:some,:_1,:_2) do |_,_| puts 'VlxTest::Test::some<:_1,:_2> ' end
+
+      vlxm(:some,:_1) do |_| 
+        puts 'VlxTest::Test::some<:_1> ' 
+      end
+
+      vlxm(:some,Symbol,Symbol) do |s,s1| 
+        puts 'VlxTest::Test::some<Symbol,Symbol> ' + s.to_s + ' ' + s1.to_s 
+      end
+
+    end # Test
+
+  end # Inner
+  end # VlxTest
+  
+
+  puts 'class test begin'
+  c = VlxTest::Inner::Test
+  c.new('Test1').some('aa')
+  c.new('Test2').some('aa')
+  puts 'class test end'
+
+end
+
+
+
+
+
+

data/vlx_multi.rb

@@ -0,0 +1,468 @@
+=begin
+Multimethod call in http://rubyforge.org/projects/multimethod and http://rubyforge.org/projects/multi/ 
+implements as several table lookups.
+
+Vlx-multimethods generate single method definition for all overloads of one message with series of if-then-else 
+condition for all patterns. Overloading allowed by value, by class, by regexp, by custom condition.
+
+=end
+
+
+require 'facets/module/modspace'
+require 'facets/module/basename'
+require 'facets/proc/bind'
+
+@@vlx_multi_methods_hook = self
+
+
+
+module Vlx
+module MultiMethods
+
+@@debug = false
+@@keys_map = {}
+
+def self.debug?
+  @@debug
+end
+
+def self.debug=(v)
+  @@debug = v
+end
+
+class IsValidDef
+
+  def self.s_prev(a,j,t,i)
+    return nil if i == 0 && j == 0
+    return t[i-1,1] if i > 0
+    p = a[j-1]
+    p[p.size-1,1]
+  end
+
+  def self.s_next(a,j,t,i)
+    return nil if i == t.size - 1 && j == a.size - 1
+    return t[i+1,1] if i+1 < t.size
+    a[j+1][0,1]
+  end
+
+  def self.good_char?(c)
+    return true if c == nil
+    return false if c == '_'
+    return false if /\d+/.match(c) != nil
+    return true
+  end
+
+  def self.index_(a,j,i)
+    o = 0
+    k = 0
+    while k < j
+      o = o + a[k].size
+      k = k + 1 
+    end
+    o + i
+  end
+
+  def self.in_string?(s,min,count)
+    c1c = s[min,count].count "'"
+    c2c = s[min,count].count '"'
+    c1c % 2 != 0 || c1c % 2 != 0
+  end
+
+  def self.check(t)
+    ur = []
+    r = []
+    t.each('_'){ |e| r << e }
+    #p r 
+    i=0
+    while i < r.size
+      c = r[i]
+      i = i + 1
+      index = c.index('_')
+      next if index == nil
+      #puts 'check: ' + c
+      sPrev = s_prev( r, i-1, c, index )
+      sNext = s_next( r, i-1, c, index )
+      if good_char?(sPrev) && good_char?(sNext) then
+        i1 = index_(r,i-1,index)
+        if !in_string?( t, 0, i1 ) then
+          #puts c
+          ur << i1
+        end
+      end
+    end
+    ur
+  end
+
+end
+
+
+class Def
+  def initialize(text)
+    @text = text    
+  end
+    
+  attr_reader :text
+end
+
+
+class ArgBase
+
+  def initialize( arg )
+    @arg = arg
+  end
+    
+  attr_reader :arg
+end
+
+
+class ArgDef < ArgBase
+  def text(param)
+    p = @arg.text.dup
+    offset = 0
+    IsValidDef.check(@arg.text).each { |index|
+      p[offset + index] = param
+      offset = offset + param.size - 1
+    }
+    #puts @arg.text + ' -> ' + p
+    p
+  end
+end
+
+
+class ArgValue < ArgBase   
+  def text(i)
+    i + ' == ' + @arg.inspect
+  end
+end
+
+
+class ArgRegexp < ArgBase
+  def text(i)
+    i + '.class == String && ' + @arg.inspect + '.match(' + i +')'
+  end
+end
+
+
+class ArgClass < ArgBase
+  def text(i)
+    i + '.is_a?(' + @arg.to_s + ')'
+  end
+
+  def is_superclass?(p)    
+    s = @arg
+    pClass = p.arg
+    while s != nil
+      return true if s == pClass
+      s = s.superclass
+    end
+    false
+  end
+    
+  def compare_by_superclass(p)
+    return -1 if is_superclass?(p) == true
+    return 1 if p.is_superclass?(self) == true
+    0
+  end
+end
+
+
+class Pattern
+
+  @@blocks_map = {}
+  @@args = [ ArgValue, ArgRegexp, ArgDef, ArgClass ]
+  
+  def self.blocks_map
+    @@blocks_map
+  end
+
+ 
+  def cond_code
+    r = ''
+    i = 0
+    @a.each{ |arg|
+      p = 'p_' + i.to_s
+      r = r + (i == 0 ? '' : ' and ') + arg.text( p )
+      i = i + 1
+    }     
+    r
+  end
+  
+  def block
+    @b
+  end
+
+  def initialize(args,block)
+    @a = []
+    args.each{|a|
+      aClass = a.class
+      if aClass == Class then
+        @a << ArgClass.new( a )     
+      elsif aClass == Regexp then
+        @a << ArgRegexp.new( a )
+      elsif aClass == Def then
+        @a << ArgDef.new( a )        
+      else
+        @a << ArgValue.new( a )
+      end    
+    
+    }
+    @b = block
+    @@blocks_map[ block.__id__ ] = block
+  end
+  
+  def array
+    @a
+  end
+  
+  @@compare_table = {}
+  
+  def make_compare_(p,m,c,c2)
+    g = @@args.index(c)
+    g2 = @@args.index(c2)
+    Proc.new{ |a,b| [p.call(a,b) * m,g,g2] }
+  end
+  
+  def pow(n,k)
+    return 1 if k == 0
+    return n if k == 1
+    return n * pow(n,k-1)
+  end
+  
+  def priority_of(a)
+    return pow(100,@@args.index(a))
+  end
+  
+  def reg_compare_(a,b,p)
+    aP = priority_of(a)
+    bP = priority_of(b)
+    m = 1
+    if aP > bP then
+      #t = a
+      #a = b
+      #b = t
+      m = -1
+    end
+    #@@compare_table[ [a,b] ] = make_compare_( p, 1, b, a )
+    #@@compare_table[ [b,a] ] = make_compare_( p, -1, b, a )  
+    @@compare_table[ [a,b] ] = make_compare_( p, m, a, b )
+    @@compare_table[ [b,a] ] = make_compare_( p, -m, b, a )    
+  end
+
+  def reg_compare_single_(a,p)
+    @@compare_table[ [a,a] ] = make_compare_( p, 1, a, a )
+  end
+
+  def compare_table_init  
+    byId = Proc.new { |a,b| a.__id__ <=> b.__id__ }
+    cc = Proc.new { |a,b| a.compare_by_superclass(b) }
+    m1 = Proc.new { |a,b| -1 }
+  
+    reg_compare_single_ ArgValue, byId
+    reg_compare_single_ ArgRegexp, byId
+    reg_compare_single_ ArgDef, byId
+    reg_compare_single_ ArgClass, cc
+
+    reg_compare_( ArgValue, ArgClass, m1 )
+    reg_compare_( ArgValue, ArgDef, m1 )
+    reg_compare_( ArgValue, ArgRegexp, m1 )
+    reg_compare_( ArgDef, ArgRegexp, m1 )
+    reg_compare_( ArgRegexp, ArgClass, m1 )
+    reg_compare_( ArgDef, ArgClass, m1 )
+    
+  end
+
+
+  def compare_(a,b)  
+    compare_table_init if @@compare_table.size == 0   
+    return @@compare_table[ [a.class,b.class] ].call(a,b)   
+  end
+
+  def compare(other)
+    return 0 if self.equal?(other)
+    
+    i = 0
+    maxg = [-1,-1,-1]
+    total = Array.new(@@args.size,0)
+    totalOther = Array.new(@@args.size,0)
+
+    other.array.each{ |otherE|
+      myE = @a[i]      
+      cr = compare_( myE, otherE )
+      myG = cr[1]
+      otherG = cr[2]
+      maxG = myG < otherG ? otherG : myG
+      total[myG] = total[myG] + 1
+      totalOther[otherG] = totalOther[otherG] + 1
+      if maxG > maxg[0] && cr[0] != 0 then
+        maxg[0] = maxG
+        maxg[1] = i
+        maxg[2] = cr[0]
+      end
+      i = i + 1
+    }
+    
+    i = total.size
+    while i >= 0
+      i = i - 1
+      return -1 if total[i] < totalOther[i]
+      return 1 if total[i] > totalOther[i]
+    end
+    
+    
+    return -1 if maxg[2] < 0
+    return 1 if maxg[2] > 0
+    return 0   
+
+  end
+  
+end
+
+
+class Data
+
+  def initialize( obj, method_name )
+    @obj = obj
+    @method_name = method_name
+    @args = []
+  end
+  
+  
+  def add( args, block )
+    argsCount = args.size
+    if @args.size <= argsCount then      
+      i = @args.size
+      while i <= argsCount
+        @args << []
+        i = i + 1
+      end
+    end
+    
+    @args[ argsCount ] << Pattern.new( args, block )
+    gen( argsCount )
+  end
+  
+  def print_args
+    @args.each { |a| p a }
+  end
+  
+  
+  def gen_i( argsCount, t )
+    args = @args[argsCount]
+    
+    return if args.empty?
+  
+    t << $/ << 'when ' << argsCount.to_s << $/
+    argsCount.times { |k|
+      t << 'p_' << k.to_s << ' = args[' << k.to_s << ']; '          
+    }
+    
+    t << 'vlxBlockIndex = nil '
+    
+    callText = ''
+    argsCount.times { |i| 
+      callText << 'p_' << i.to_s
+      callText << ', ' if i < argsCount - 1
+    }
+
+    first = true
+    args.each do |arg|    
+      t << $/ << (first ? 'if ' : 'elsif ') << arg.cond_code << ' then ' << $/ <<
+           'vlxBlockIndex = ' << arg.block.__id__.to_s 
+      first = false
+    end
+    t << $/ << 'end ' << $/ << 'vlxB = vlxmmBlocksMap[vlxBlockIndex]' << $/
+    t << 'if self.class == Module then return vlxB.call(*args) else return vlxB.bind(self)[*args] end'
+    
+  end
+  
+
+  def parents(c)
+    r = []
+    while c != nil
+      r << c
+      c = c.modspace
+      break if c == Object
+    end
+    r
+  end
+  
+  def gen( argsCount )    
+    args = @args[argsCount]
+    args.sort! do |x,y|
+      x.compare(y)
+    end
+
+    prefix = ''
+    postfix = ''
+    selfText = 'self.'
+    if @obj.__id__ == @@vlx_multi_methods_hook.__id__
+      ;     
+    elsif @obj.class == Class
+      a = parents(@obj).reverse
+      prefix = ''
+      a.each{ |e|
+        prefix << 'class ' if e.class == Class
+        prefix << 'module ' if e.class == Module
+        prefix << e.basename << $/
+        postfix << 'end '
+      }
+      
+      selfText = ''
+      
+    elsif @obj.class == Module 
+      a = []
+      @obj.name.each('::') { |e| 
+        a << e.delete('::') 
+      }
+      prefix = ''
+      a.each { |e|
+        prefix << 'module ' << e.to_s << $/
+        postfix << 'end '
+      }
+    else
+      throw 'VlxMultiNethods register code generation failed ' + @obj.inspect
+    end
+
+    t = ''
+    t << prefix << $/
+    t << 'def ' << selfText << @method_name.to_s << '( *args )' << $/
+    t << 'vlxmmBlocksMap = Vlx::MultiMethods::Pattern.blocks_map' << $/
+    
+    i = 0
+    t << 'case args.size'
+    @args.each { |argList|
+      gen_i( i, t )
+      i = i + 1
+    }
+    t << $/ << 'else ' << $/ << ' end' << $/    
+    t << '  throw "unknown pattern " + args.inspect + ' << " ' for method " << @method_name.to_s << "'" << $/
+    t << 'end' << $/
+    t << postfix << $/
+    puts t if Vlx::MultiMethods.debug? == true 
+    
+    
+    #p @@vlx_multi_methods_hook
+    @@vlx_multi_methods_hook.send( :eval, t, TOPLEVEL_BINDING )
+      
+  end
+  
+end
+
+def self.reg( obj, method_name, args, block )
+  key = [ obj, method_name ] 
+  data = @@keys_map.fetch( key ) { d = Data.new( obj, method_name ); @@keys_map[key] = d; d }
+  data.add( args, block )
+end
+
+
+end # MultiMethods
+end # Vlx
+
+
+def vlxm( symbol, *args, &block )
+  Vlx::MultiMethods.reg( self, symbol, args, block )
+end
+
+def vlxmd(text)
+  Vlx::MultiMethods::Def.new(text)
+end

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: vlx-multi
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Kornyushenko Eugene
+autorequire: vlx-multi
+bindir: bin
+cert_chain: []
+
+date: 2008-07-14 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: kornyushenko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- vlx_multi.rb
+- sample.rb
+has_rdoc: false
+homepage: http://rubyforge.org/projects/vlx-multi/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: vlx-multi
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Multiple Dispatch/Pattern Matching for Ruby
+test_files: []
+