em-rserve 0.1.0

data/lib/em-rserve/r/sexp.rb

@@ -0,0 +1,421 @@
+
+require 'em-rserve/qap1/constants'
+
+module EM::Rserve
+  module R
+    class Sexp
+      include QAP1::Constants
+
+      XT_NULL = 0
+      XT_INT = 1
+      XT_DOUBLE = 2
+      XT_STR = 3
+      XT_LANG = 4
+      XT_SYM = 5
+      XT_BOOL = 6
+      XT_S4 = 7  
+
+      XT_VECTOR = 16 
+      XT_LIST = 17 
+      XT_CLOS = 18 
+      XT_SYMNAME = 19 
+      XT_LIST_NOTAG = 20 
+      XT_LIST_TAG = 21 
+      XT_LANG_NOTAG = 22 
+      XT_LANG_TAG = 23 
+      XT_VECTOR_EXP = 26 
+      XT_VECTOR_STR = 27 
+
+      XT_ARRAY_INT = 32 
+      XT_ARRAY_DOUBLE = 33 
+
+      XT_ARRAY_STR = 34 
+      XT_ARRAY_BOOL_UA = 35 
+      XT_ARRAY_BOOL = 36 
+      XT_RAW = 37 
+      XT_ARRAY_CPLX = 38 
+      XT_UNKNOWN = 48
+
+      class Node
+        attr_accessor :attribute
+        attr_accessor :children
+
+        def initialize
+          @children = []
+          @attribute = nil
+          yield self if block_given?
+        end
+
+        def descent(depth=0, &blk)
+          if block_given?
+            blk.call(self, depth)
+            @children.each do |c|
+              c.descent(depth + 1, &blk)
+            end
+          else
+            Enumerator.new(self, :descent)
+          end
+        end
+
+        def dump_sexp
+          body = dumped_value_with_attribute
+          children_data = children.map do |n|
+            n.dump_sexp
+          end.join('')
+          size = body.size + children_data.size
+          flags = {:large => false, :attr => attribute && true}
+          head = self.class.parameter_head(self.class.code, flags, size)
+          [head, body + children_data].pack('Va*')
+        end
+
+        def dumped_value_with_attribute
+          if attribute
+            attribute.dump_sexp  + dumped_value 
+          else
+            dumped_value
+          end
+        end
+
+        def dumped_value
+          ''
+        end
+
+        def self.parameter_head(type, flags, len)
+          head_bits  = type & 0x3f #high bits are for flags
+          len_bits   = (len & 0xffffff) << 8
+          flags_bits = 0
+          flags_bits |= 0x40 if flags[:large]
+          flags_bits |= 0x80 if flags[:attr]
+          ret = head_bits | len_bits | flags_bits
+          ret
+        end
+
+        class << self
+          def inherited(klass)
+            klass.instance_variable_set(:@code, nil)
+          end
+
+          def code(val=nil)
+            if val
+              @code = val
+            end
+            @code 
+          end
+        end
+
+        def self.build_map!
+          all_nodes = ObjectSpace.each_object(Class).select{|k| k.ancestors.include?(self)} - [self]
+          true_nodes = all_nodes.select(&:code)
+          pairs = true_nodes.map{|n| [n.code, n]}
+          @@map = Hash[*pairs.flatten]
+        end
+
+        def self.map
+          @@map ||= build_map!
+        end
+
+        def self.class_for_type(type)
+          map[type]
+        end
+
+        attr_accessor :rb_raw
+        alias :rb_val :rb_raw
+        alias :interpret :rb_raw=
+
+          def int2bool(i)
+            if i == 1
+              true
+            elsif i == 0
+              false
+            elsif i == 2
+              nil
+            else
+              raise "unknown bool int: #{i}"
+            end
+          end
+
+        def bool2int(b)
+          if b == true
+            1
+          elsif b == false
+            0
+          elsif b.nil?
+            2
+          else
+            raise "unknown bool for int: #{b}"
+          end
+        end
+
+        # not leaves
+        class ParentNode < Node
+          def interpret(dat)
+            @children = Sexp.decode_nodes_array(dat)
+            super(children.map(&:rb_raw))
+          end
+        end
+
+        class Root < ParentNode
+          def rb_val
+            children.first.rb_val
+          end
+
+          def dump_sexp
+            children.first.dump_sexp
+          end
+        end
+
+        class Null < Node
+          code XT_NULL
+          def interpret(dat)
+            super nil
+          end
+        end
+
+        class Bool < Node
+          code XT_BOOL
+          def interpret(dat)
+            super int2bool(dat.unpack('i').first)
+          end
+
+          def dumped_value
+            [bool2int(rb_raw)].pack('i')
+          end
+        end
+
+        class Int < Node
+          code XT_INT
+          def interpret(dat)
+            super dat.unpack('i').first
+          end
+
+          def dumped_value
+            [rb_raw].pack('i')
+          end
+        end
+
+        class Double < Node
+          code XT_DOUBLE
+          def interpret(dat)
+            super dat.unpack('d').first
+          end
+        end
+
+        class NodesArray < Node
+          def rb_val
+            if rb_raw.size > 1
+              rb_raw
+            else
+              rb_raw.first
+            end
+          end
+        end
+
+        class String < Node
+          code XT_STR
+          def interpret(dat)
+            val, padding = dat.split("\0", 2)
+            super val
+          end
+        end
+
+        class SymName < String
+          code XT_SYMNAME
+
+          def dumped_value
+            ret = rb_raw + "\0"
+            ret << "\0" * (ret.size % 4)
+            ret
+          end
+        end
+
+        class ArrayString < NodesArray
+          code XT_ARRAY_STR
+          def interpret(dat)
+            ary = dat.split("\0")
+            return(super(ary)) if ary.empty?
+            ary.pop if ary.last.tr("\1",'').empty?
+            super ary
+          end
+
+          def dumped_value
+            str = (rb_raw + ['']).join("\0")
+            str << "\1" * (str.size % 4)
+            str
+          end
+        end
+
+        class ArrayInt < NodesArray
+          code XT_ARRAY_INT
+          def interpret(dat)
+            super dat.unpack('i'*(dat.size/4))
+          end
+
+          def dumped_value
+            rb_raw.pack('i*')
+          end
+        end
+
+        class ArrayDouble < NodesArray
+          code XT_ARRAY_DOUBLE
+          def interpret(dat)
+            super dat.unpack('d'*(dat.size/8))
+          end
+
+          def dumped_value
+            rb_raw.pack('d*')
+          end
+        end
+
+        class ArrayBool < NodesArray
+          code XT_ARRAY_BOOL
+
+          def interpret(dat)
+            cnt, dat = dat.unpack('ia*')
+            super dat.unpack('c'*cnt).map{|i| int2bool(i)}
+          end
+
+          def dumped_value
+            ([rb_raw.size] + rb_raw.map{|v| bool2int(v)}).pack('ic*')
+          end
+        end
+
+        class ArrayComplex < NodesArray
+          code XT_ARRAY_CPLX
+          def interpret(dat)
+            ary = dat.unpack('d'*(dat.size/8)).each_slice(2).map do |real,imag|
+              Complex(real, imag)
+            end
+            super ary
+          end
+
+          def dumped_value
+            rb_raw.map{|cpx| [cpx.real, cpx.imag]}.flatten.pack('d*')
+          end
+        end
+
+        class NodesList < ParentNode
+        end
+
+        class ListTag < NodesList
+          code XT_LIST_TAG
+
+          def rb_val
+            ary = children.map(&:rb_val)
+            hash = Hash.new
+            ary.each_slice(2){|v,k| hash[k] = v}
+            hash
+          end
+        end
+
+        class ListNoTag < NodesList
+          code XT_LIST_NOTAG
+        end
+
+        class NodesLang < ParentNode
+        end
+
+        class LangTag < NodesLang
+          code XT_LANG_TAG
+        end
+
+        class LangNoTag < NodesLang
+          code XT_LANG_NOTAG
+        end
+
+        class Vector < ParentNode
+          code XT_VECTOR
+        end
+
+        class Raw < Node
+          code XT_RAW
+          def interpret(dat)
+            cnt,dat=dat.unpack('ia*')
+            super dat.slice(0,cnt)
+          end
+        end
+
+        class Unknown < Node
+          code XT_UNKNOWN
+        end
+
+        class Closure < ParentNode
+          code XT_CLOS 
+        end
+
+        class S4 < ParentNode
+          code XT_S4 
+        end
+      end
+
+      def self.parse(dat)
+        node = Node::Root.new
+        node.interpret(dat)
+        node
+      end
+
+      def self.head_parameter(head)
+        type = head & 0x3f #high bits are for flags
+        large_flag = !(head & 0x40 == 0) #  i.e. 1 << 6 (64)
+        attr_flag = !(head & 0x80 == 0)  #  i.e. 1 << 7 (128)
+        len  = (head & ~0xff) >> 8
+        flags = {large: large_flag, attr: attr_flag}
+        [type, flags, len]
+      end
+
+      # debugging function
+      def self.xt_type_sym(type)
+        self.constants.find{|c| self.const_get(c) == type}
+      end
+
+      # debugging function
+      def self.announce(str)
+        # puts "A:#{str}"
+      end
+
+      # Decodes a buffer given a type of node
+      def self.decode_node(type, buffer)
+        announce [xt_type_sym(type), "0x%02x" % type, buffer.size, buffer].inspect
+        klass = Node.class_for_type(type)
+        if klass
+          node = klass.new
+          node.interpret(buffer)
+          node
+        else
+          raise RuntimeError, "no Node to decode type #{type}"
+        end
+      end
+
+      # Decodes a buffer starting with a header
+      # returns an array of two elements:
+      # - the new, interpreted Node
+      # - the remainder of the buffer
+      def self.decode_nodes(buffer)
+        head, buffer = buffer.unpack('Va*')
+        type, flags, len = head_parameter(head)
+
+        # Cuts the buffer at the correct length and give away the remainder
+        buffer, remainder = buffer.unpack("a#{len}a*")
+
+        attrs = nil
+        if flags[:attr]
+          attrs, buffer = decode_nodes(buffer) 
+        end
+
+        node = decode_node(type, buffer)
+
+        node.attribute = attrs if attrs
+
+        [node, remainder]
+      end
+
+      def self.decode_nodes_array(buffer)
+        ary = []
+        until buffer.empty?
+          val, buffer = decode_nodes(buffer)
+          ary << val
+        end
+        ary
+      end
+    end
+  end
+end

data/lib/em-rserve/version.rb

@@ -0,0 +1,5 @@
+module EM
+  module Rserve
+    VERSION = "0.1.0"
+  end
+end

data/lib/em-rserve.rb

@@ -0,0 +1,11 @@
+require 'eventmachine'
+require "em-rserve/version"
+require "em-rserve/connection"
+require "em-rserve/r/r_to_ruby/translator"
+require "em-rserve/r/ruby_to_r/translator"
+
+module EM
+  module Rserve
+    # Your code goes here...
+  end
+end

data/samples/assign.rb

@@ -0,0 +1,211 @@
+#example which shows how various R objects are dumped and translated in Ruby
+$LOAD_PATH << './lib'
+
+require 'em-rserve'
+require 'pp'
+
+class DevelConnection < EM::Rserve::Connection
+  attr_reader :request_queue
+
+  def dump_sexp(msg)
+    raise unless msg.parameters.size == 1
+    root = msg.parameters.first
+    pp root
+    val =  EM::Rserve::R::RtoRuby::Translator.r_to_ruby(root)
+    p val
+  end
+
+  def dump_r_val(str) 
+    r_eval(str) do |req|
+      req.callback do |msg|
+        dump_sexp msg
+      end
+    end
+  end
+
+  def assign_and_debug_node(sym, node)
+    assign(sym, node) do |req|
+      req.errback do |err|
+        puts 'could not assign'
+      end
+      req.callback do |msg|
+        puts 'assigned'
+        dump_r_val sym.to_s
+      end
+    end
+  end
+
+  def loop_parse_r_val(str)
+    r_eval(str) do |req|
+      req.callback do |msg|
+        raise unless msg.parameters.size == 1
+        root = msg.parameters.first
+        new_root = EM::Rserve::R::Sexp.parse(root.dump_sexp)
+        val1 =  EM::Rserve::R::RtoRuby::Translator.r_to_ruby(root)
+        val2 =  EM::Rserve::R::RtoRuby::Translator.r_to_ruby(new_root)
+        if val1 == val2
+          p "ok: #{str}" 
+        else
+          p "ko: #{str}"
+        end
+      end
+    end
+  end
+
+  def do_int
+    do_array_int([1])
+  end
+
+  def do_array_int(ints=[1,2,3,4,5])
+    root = EM::Rserve::R::Sexp::Node::Root.new
+    array = EM::Rserve::R::Sexp::Node::ArrayInt.new
+    array.rb_raw = ints
+    root.children << array
+    assign_and_debug_node :lol, root
+  end
+
+  def do_double
+    do_array_double [3.14]
+  end
+
+  def do_array_double(doubles=[1,2,3,4.2])
+    root = EM::Rserve::R::Sexp::Node::Root.new
+    array = EM::Rserve::R::Sexp::Node::ArrayDouble.new
+    array.rb_raw = doubles
+    root.children << array
+    assign_and_debug_node :lol, root
+  end
+
+  def do_array_bool(bools=[true, false, nil])
+    root = EM::Rserve::R::Sexp::Node::Root.new
+    array = EM::Rserve::R::Sexp::Node::ArrayBool.new
+    array.rb_raw = bools
+    root.children << array
+    assign_and_debug_node :lol, root
+  end
+
+  def do_true
+    do_array_bool [true]
+  end
+
+  def do_false
+    do_array_bool [false]
+  end
+
+  def do_nil
+    do_array_bool [nil]
+  end
+
+  def do_string
+    do_array_string ["lulzor"]
+  end
+
+  def do_array_string(strs=['for', 'great', 'justice'])
+    root = EM::Rserve::R::Sexp::Node::Root.new
+    array = EM::Rserve::R::Sexp::Node::ArrayString.new
+    array.rb_raw = strs
+    root.children << array
+    assign_and_debug_node :lol, root
+  end
+
+  def do_table_for_ints
+    root = EM::Rserve::R::Sexp::Node::Root.new do |root|
+      root.children << EM::Rserve::R::Sexp::Node::ArrayInt.new do |node|
+        node.rb_raw = [1,3,1]
+        node.attribute = EM::Rserve::R::Sexp::Node::ListTag.new do |attr|
+          attr.children << EM::Rserve::R::Sexp::Node::ArrayInt.new do |val|
+            val.rb_raw = [3]
+          end
+          attr.children << EM::Rserve::R::Sexp::Node::SymName.new do |val|
+            val.rb_raw = "dim"
+          end
+          attr.children << EM::Rserve::R::Sexp::Node::Vector.new do |vector|
+            vector.attribute = EM::Rserve::R::Sexp::Node::ListTag.new do |tags|
+              tags.rb_raw = [[''], "names"] #XXX should not be necessary to correct dump
+              tags.children << EM::Rserve::R::Sexp::Node::ArrayString.new do |strings|
+                strings.rb_raw = ['']
+              end
+              tags.children << EM::Rserve::R::Sexp::Node::SymName.new do |val|
+                val.rb_raw = 'names'
+              end
+            end
+            vector.children << EM::Rserve::R::Sexp::Node::ArrayString.new do |strings|
+              strings.rb_raw = ['1', '2', '3']
+            end
+            vector.rb_raw = [['1', '2', '3']] #XXX should not be needed
+          end
+          attr.children << EM::Rserve::R::Sexp::Node::SymName.new do |val|
+            val.rb_raw = "dimnames"
+          end
+          attr.children << EM::Rserve::R::Sexp::Node::ArrayString.new do |val|
+            val.rb_raw = ["table"]
+          end
+          attr.children << EM::Rserve::R::Sexp::Node::SymName.new do |val|
+            val.rb_raw = "class"
+          end
+          attr.rb_raw = [[3], "dim", [["1", "2", "3"]], "dimnames", ["table"], "class"] #XXX should not be needed
+        end
+        root.rb_raw = [[1, 3, 1]]
+      end
+    end
+
+    assign_and_debug_node :lol, root
+  end
+
+  def ready
+    puts "ready"
+
+    loop_parse_r_val '1+1i'
+    loop_parse_r_val 'c(1:1000)'
+    loop_parse_r_val 'c(1:10000000)'
+
+    return
+
+    root = EM::Rserve::R::RubytoR::Translator.ruby_to_r ['hello', 'world']
+    assign_and_debug_node :lol, root
+    
+    root = EM::Rserve::R::RubytoR::Translator.ruby_to_r [400, 30, 12]
+    assign_and_debug_node :lol, root
+
+    root = EM::Rserve::R::RubytoR::Translator.ruby_to_r(:foo => [1,2,3], 
+                                                        :bar => ['a', 'b', 'c'])
+    assign_and_debug_node :lol, root
+
+    return
+
+    loop_parse_r_val 'c(1:5)'
+    loop_parse_r_val 'table(c(1,2,3,2,2))'
+    loop_parse_r_val "data.frame(foo=c(1:8), bar=seq(100,800,100))"
+    loop_parse_r_val "data.frame(foo=c(1,2,3), bar=c(NA,FALSE,TRUE), row.names=c('foo','bar','baz'))" 
+    
+    #do_int
+    #do_double
+    #do_true
+    #do_false
+    #do_nil
+    #do_string
+    
+    #do_array_int
+    #do_array_double
+    #do_array_bool
+    #do_array_string
+
+    #do_table_for_ints
+
+    #r_eval 'table(c(1,2,3,2,2))'
+    #table:
+    # root 
+    #  ArrayInt
+    #
+
+    return
+    r_eval 'function(a,b=2){a+b}' 
+    r_eval 'ls'
+    r_eval 'print'
+  end
+
+end
+
+EM.run do
+  DevelConnection.start
+end

data/samples/detach_attach.rb

@@ -0,0 +1,70 @@
+#this sample will detach a session and reattach a session in a new connection
+$LOAD_PATH << './lib'
+
+require 'em-rserve'
+
+$KEYPORT = false
+
+class DevelConnection < EM::Rserve::Connection
+  attr_reader :request_queue
+
+  def post_init
+    super
+    if $KEYPORT
+      replace_parser! EM::Rserve::Protocol::MessageParser
+      key = $KEYPORT.last
+      attach key do |req|
+        req.callback do |msg|
+          p "attached"
+          shutdown!
+        end
+        req.errback do |err|
+          p "not attached"
+        end
+      end
+      r_eval "ls()" do |req|
+        req.callback do |msg|
+          p msg
+        end
+        req.errback do |err|
+          p err
+        end
+      end
+      #shutdown!
+    end
+  end
+
+  def ready
+    p "ready"
+    if $KEYPORT
+      key = $KEYPORT.last
+    else
+      r_eval "a <- c(1:10)"
+      detach do |d|
+        d.callback do |msg|
+          puts "detached"
+          $KEYPORT = msg.parameters
+          port = $KEYPORT.first
+          puts "connecting: #{port}"
+          EM::next_tick do
+            DevelConnection.start('127.0.0.1', port)
+          end
+        end
+      end
+    end
+  end
+
+  def detach
+    puts "detaching"
+    super
+  end
+
+  def attach(key, &blk)
+    puts "attaching"
+    super
+  end
+end
+
+EM.run do
+  DevelConnection.start
+end