em-rserve 0.1.0

data/lib/em-rserve/qap1/message.rb

@@ -0,0 +1,26 @@
+
+require 'em-rserve/qap1/rpack'
+
+module EM::Rserve
+  module QAP1
+    class Message
+      extend Rpack
+
+      def self.from_bin(dat)
+        new decode_parameters(dat)
+      end
+
+      attr_reader :parameters
+
+      def initialize(params=[])
+        @parameters = params
+      end
+
+      def pack_parameters
+        parameters.map{|p| self.class.encode_parameter(p)}.join
+      end
+
+      alias :to_bin :pack_parameters
+    end
+  end
+end

data/lib/em-rserve/qap1/rpack.rb

@@ -0,0 +1,127 @@
+
+require 'em-rserve/qap1/constants'
+require 'em-rserve/r/sexp'
+
+module EM::Rserve
+  module QAP1
+    module Rpack
+      include Constants
+      include R
+
+      def parameter_head(type, len)
+        #TODO: support long parameter, type: 0xbf + DT_LARGE if len overflows
+        (type & 0x000000ff) | ((len << 8) & 0xffffff00)
+      end
+
+      def pack_parameter(type, len, val, rule)
+        [parameter_head(type, len), val].flatten.pack('V'+rule)
+      end
+
+      def encode_parameter(param, type=nil)
+        type ||= param
+        case param
+        when Integer, :int
+          encode_int param
+        when :char
+          encode_char param
+        when Float, :double
+          encode_double param
+        when String, :string
+          encode_string param
+        when Sexp::Node
+          encode_sexp_node param
+        when :bytestream
+          encode_bytestream param
+          #XXX Array and rest
+        end
+      end
+
+      def encode_int(val)
+        pack_parameter(DT_INT, 4, val, 'V')
+      end
+
+      def encode_char(val)
+        pack_parameter(DT_CHAR, 1, val, 'C')
+      end
+
+      def encode_double(val)
+        pack_parameter(DT_DOUBLE, 8, val, 'D')
+      end
+
+      def encode_string(val, len=nil, has_null=false)
+        if has_null
+          len ||= val.length
+          pack_parameter(DT_STRING, len, val, 'a*')
+        else
+          len ||= val.length + 1
+          pack_parameter(DT_STRING, len, [val, 0], 'a*C')
+        end
+      end
+
+      def encode_bytestream(val, len=nil)
+        len ||= val.length
+        pack_parameter(DT_BYTESTREAM, len, val, 'a*')
+      end
+
+      def encode_large(val, len=nil)
+      end
+
+      def encode_sexp_node(node, len=nil)
+        dat = node.dump_sexp
+        len ||= dat.length
+        pack_parameter(DT_SEXP, len, dat, 'a*')
+      end
+
+      def encode_array(val, len=nil)
+      end
+
+      def head_parameter(head)
+        type = head & 0x000000bf 
+        large = (head & DT_LARGE) > 0
+        len  = (head & 0xffffff00) >> 8
+        [type, len, large]
+      end
+
+      def decode_sexp(dat)
+        Sexp.parse(dat)
+      end
+
+      def decode_int(dat)
+        dat.unpack('i').first
+      end
+
+      def decode_bytestream(dat)
+        dat
+      end
+
+      def decode_parameter(type, dat, len=nil)
+        case type
+        when DT_SEXP
+          decode_sexp dat
+        when DT_INT
+          decode_int dat
+        when DT_BYTESTREAM
+          decode_bytestream dat
+        else 
+          p "missing decode: #{type}"
+        end
+      end
+
+      def decode_parameters(buffer)
+        params = []
+        until buffer.empty? do
+          head, buffer = buffer.unpack('Va*')
+          type, len, large = head_parameter(head)
+          raise NotImplementedError, "too long QAP1 message" if large
+          if buffer.size < len
+            raise RuntimeError, "cannot decode #{buffer} (not enough bytes)"
+          end
+          param_data = buffer.slice(0, len)
+          buffer = buffer.slice(len .. -1)
+          params << decode_parameter(type, param_data, len)
+        end
+        params
+      end
+    end
+  end
+end

data/lib/em-rserve/r/r_to_ruby/translator.rb

@@ -0,0 +1,152 @@
+
+require 'em-rserve/r/sexp'
+
+module EM::Rserve
+  module R
+    module RtoRuby
+      class Translator
+        def self.r_to_ruby(root)
+          node = root.children.first
+          attR = node.attribute
+
+          pair = [node.class, attR.class]
+          klass = case pair
+                  when [Sexp::Node::ArrayInt, NilClass]
+                    ArrayTranslator
+                  when [Sexp::Node::ArrayBool, NilClass]
+                    ArrayTranslator
+                  when [Sexp::Node::ArrayString, NilClass]
+                    ArrayTranslator
+                  when [Sexp::Node::ArrayDouble, NilClass]
+                    ArrayTranslator
+                  when [Sexp::Node::ArrayComplex, NilClass]
+                    ArrayTranslator
+                  when [Sexp::Node::ArrayDouble, Sexp::Node::ListTag]
+                    DateTranslator
+                  when [Sexp::Node::ArrayInt, Sexp::Node::ListTag]
+                    FactorTableTranslator
+                  when [Sexp::Node::Vector, Sexp::Node::ListTag]
+                    DataFrameTranslator
+                  when [Sexp::Node::Closure, NilClass]
+                    ClosureTranslator
+                  else
+                    DefaultTranslator
+                  end
+          klass.new(node).translate 
+        end
+
+        attr_reader :node
+
+        def initialize(node=nil)
+          @node = node
+        end
+
+        def translate
+          throw :cannot_translate
+        end
+
+        class DefaultTranslator < Translator
+        end
+
+        class ArrayTranslator < Translator
+          def translate
+            node.rb_val
+          end
+        end
+
+        class DateTranslator < Translator
+          def translate
+            case node.attribute.rb_val['class']
+            when 'Date'
+              Time.at(node.rb_val * 86400) # R gives days Ruby wants secs
+            else
+              super
+            end
+          end
+        end
+
+        class FactorTableTranslator < Translator
+          # Symbols represented by ints
+          class Factor < Array
+            attr_accessor :levels
+          end
+
+          # Frequency table
+          class Table < Hash
+          end
+
+          def translate_factor
+            levels = node.attribute.rb_val['levels']
+            levels = levels.map{|str| str.to_sym}
+            ret = Factor.new.replace(node.rb_val.map{|i| levels[i-1]})
+          end
+
+          def translate_table
+            keys = node.attribute.rb_val['dimnames'].first
+            vals = node.rb_val
+            Table[ keys.zip(vals) ]
+          end
+
+          def translate
+            case node.attribute.rb_val['class']
+            when 'factor'
+              translate_factor
+            when 'table'
+              translate_table
+            else
+              super
+            end
+          end
+        end
+
+        class DataFrameTranslator < Translator
+          class DataFrame < Hash
+            attr_accessor :rows, :r_class
+
+            def inspect
+              super.sub(/}$/," @r_class: #{r_class}, @rows: #{rows}")
+            end
+
+            def each_struct
+              if block_given?
+                all_keys = keys #not sure keys will always return the same order
+                struct = Struct.new(*all_keys.map(&:to_sym))
+                #XXX when we map and transpose, we actually do computation before they
+                #are needed, could improve with true-style iterators
+                all_keys.map{|k| self[k]}.transpose.each do |values|
+                  yield struct.new(*values)
+                end
+              else
+                Enumerator.new(:self, :each_struct)
+              end
+            end
+          end
+
+          def translate_data_frame
+            attrs = node.attribute.rb_val
+            cols = [attrs['names']].flatten
+            rows = case attrs['row.names']
+                   when [-2147483648, -8]
+                     nil
+                   else
+                     [attrs['row.names']].flatten
+                   end
+
+            dfrm = DataFrame[ cols.zip(node.rb_val) ]
+            dfrm.rows = rows if rows
+            dfrm
+          end
+
+          def translate
+            h = translate_data_frame
+            h.r_class = node.attribute.rb_val['class']
+            h
+          end
+        end
+
+        class ClosureTranslator < Translator
+        end
+      end
+    end
+  end
+end

data/lib/em-rserve/r/ruby_to_r/translator.rb

@@ -0,0 +1,131 @@
+require 'em-rserve/r/sexp'
+
+module EM::Rserve
+  module R
+    module RubytoR
+      class Translator
+
+        def self.translator_klass_for(obj)
+          case obj
+          when Array
+            ArrayTranslator
+          when Hash
+            HashTranslator
+          else
+            SingleObjectTranslator
+          end
+        end
+
+        def self.ruby_to_r(obj)
+          translator_klass_for(obj).new(obj).translate 
+        end
+
+        attr_reader :obj
+
+        def initialize(obj=nil)
+          @obj = obj
+        end
+
+        def translate
+          throw :cannot_translate
+        end
+
+        class SingleObjectTranslator < Translator
+          def translate
+            Translator.ruby_to_r [obj]
+          end
+        end
+
+        class ArrayTranslator < Translator
+          MAPPING = {String => EM::Rserve::R::Sexp::Node::ArrayString,
+            Integer => EM::Rserve::R::Sexp::Node::ArrayInt,
+            Float => EM::Rserve::R::Sexp::Node::ArrayDouble,
+            NilClass => EM::Rserve::R::Sexp::Node::ArrayBool,
+            TrueClass => EM::Rserve::R::Sexp::Node::ArrayBool,
+            FalseClass => EM::Rserve::R::Sexp::Node::ArrayBool,
+          }
+
+          def array_node_class
+            classes = obj.map(&:class).uniq
+            if classes.size == 1
+              obj_klass = classes.first
+              MAPPING.each_pair do |klass, node|
+                return node if obj_klass.ancestors.include?(klass)
+              end
+            elsif (classes - [TrueClass,NilClass,FalseClass]).empty?
+              EM::Rserve::R::Sexp::Node::ArrayBool
+            elsif (classes - [Float, Fixnum]).empty?
+              EM::Rserve::R::Sexp::Node::ArrayDouble
+            else
+              nil
+            end
+          end
+
+          def translate
+            klass = array_node_class
+            throw :cannot_translate unless klass
+            EM::Rserve::R::Sexp::Node::Root.new do |root|
+              klass.new do |array|
+                array.rb_raw = obj
+                root.children << array
+              end
+            end
+          end
+        end
+
+        class HashTranslator < Translator
+          def list_node_class
+            EM::Rserve::R::Sexp::Node::Vector
+          end
+
+          def list_node_attribute_class
+            EM::Rserve::R::Sexp::Node::ListTag
+          end
+
+          def translate
+            klass = list_node_class
+            attr_klass = list_node_attribute_class
+            throw :cannot_translate unless klass and attr_klass
+            raise :cannot_translate if obj.empty?
+            pairs = obj.each_pair.to_a
+            size = pairs.first.last.size
+            #TODO: check if sizes differ and raise
+            EM::Rserve::R::Sexp::Node::Root.new do |root|
+              klass.new do |vector|
+                vector.attribute = attr_klass.new do |taglist|
+                  # add ArrayString with keys as strings for column names
+                  # add SymName "names"
+                  taglist.children << ArrayTranslator.new(pairs.map(&:first).map(&:to_s)).translate.children.first
+                  sym = EM::Rserve::R::Sexp::Node::SymName.new
+                  sym.rb_raw = "names"
+                  taglist.children << sym
+                  # add ArrayInt -2147483648, -(size) for rows
+                  # add SymName "row.names"
+                  taglist.children << ArrayTranslator.new([-2147483648, 0 - size]).translate.children.first
+                  sym = EM::Rserve::R::Sexp::Node::SymName.new
+                  sym.rb_raw = "row.names"
+                  taglist.children << sym
+
+                  # add ArrayString "data.frame"
+                  # add SymName "class"
+                  taglist.children << ArrayTranslator.new(["data.frame"]).translate.children.first
+                  sym = EM::Rserve::R::Sexp::Node::SymName.new
+                  sym.rb_raw = "class"
+                  taglist.children << sym
+                end #attribute
+
+                pairs.each do |k,values|
+                  array_node = ArrayTranslator.new(values).translate.children.first
+                  vector.children << array_node
+                end #children
+                root.children << vector
+              end #vector
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+