rserve-client 0.1.5 → 0.1.6

data/lib/rserve/rfactor.rb

@@ -16,8 +16,8 @@ module Rserve
       @index_base=index_base
     end
     # returns the level of a given case
-		# * @param i case number
-		# * @return name. may throw exception if out of range 
+    # * @param i case number
+    # * @return name. may throw exception if out of range
     def [](i)
       li = @ids[i]-index_base
       return (li<0 or li>levels.length) ? nil : levels[li]
@@ -26,16 +26,16 @@ module Rserve
       li=level_index(li) if li.is_a? String
       @ids.any? {|v| v==li}
     end
-    
-   # return the index of a given level name or -1 if it doesn't exist
+
+    # return the index of a given level name or -1 if it doesn't exist
     def level_index(name)
-        return nil if name.nil?
-        levels.length.times {|i|
-          return i+index_base if !levels[i].nil? and levels[i]==name
-        }
-        return nil
+      return nil if name.nil?
+      levels.length.times {|i|
+        return i+index_base if !levels[i].nil? and levels[i]==name
+      }
+      return nil
     end
-    def count(li) 
+    def count(li)
       li=level_index(li) if li.is_a? String
       @ids.inject(0) {|ac,v| ac+ ((v==li) ? 1 : 0 ) }
     end

data/lib/rserve/rlist.rb

@@ -4,118 +4,147 @@ module Rserve
     attr_reader :names
     attr_reader :data
     def initialize(data=nil,n=nil)
-       @names=nil
-       @data=[]
-       if data
-         @data=case data
-                    when Array
-                    data
-                    when Numeric
-                    Array.new(data)
-                    else
-                    raise ArgumentError
-                end
-        end
-        if n
-        @names=Array.new(@data.size)
-         n.each_index {|i| @names[i]=n[i]} if n.respond_to? :each_index
-        end
-      end
-    def named?
-      !@names.nil?
-    end
-    def [](v)
-      if v.is_a? String
-        return nil if @names.nil?
-        i=@names.index(v)
-        return i.nil? ? nil : @data[i]
-      elsif v.is_a? Integer
-        return @data[i]
+      @names=nil
+      @data=[]
+      if data
+        @data=case data
+      when Array
+        data
+      when Numeric
+        Array.new(data)
       else
-        raise ArgumentError,"Should be String or Integer"
+        raise ArgumentError
       end
     end
-    
-    def at(v)
-      self.[](v)
-    end
-    
-    def key_at(v)
-      return nil if @names.nil?
-      @names[v]
+    if n
+      @names=Array.new(@data.size)
+      n.each_index {|i| @names[i]=n[i]} if n.respond_to? :each_index
     end
-    def size
-      @data.size
+  end
+  def named?
+    !@names.nil?
+  end
+  def ==(o)
+    #p "Comparing #{self.inspect} with #{o.inspect} gives #{o.is_a? Rlist and self.data==o.data and self.names==o.names}"
+    o.is_a? Rlist and self.data==o.data and self.names==o.names
+  end
+  # Return element with name x or 0-index x
+  def [](v)
+    if v.is_a? String
+      return nil if @names.nil? or v==""
+      i=@names.index(v)
+      return i.nil? ? nil : @data[i]
+    elsif v.is_a? Integer
+      return @data[v]
+    else
+      raise ArgumentError,"Should be String or Integer"
     end
-    
-    def each
-      @data.each do |v|
-        yield v
-      end
+  end
+
+  def at(v)
+    self.[](v)
+  end
+
+  def key_at(v)
+    return nil if @names.nil?
+    @names[v]
+  end
+  def size
+    @data.size
+  end
+
+  def each
+    @data.each do |v|
+      yield v
     end
-    
-    def set_key_at(i,value)
-      if @names.nil?
-        @names=Array.new
-      end
-      if @names.size<size
-        (size-@names.size).times {@names.push(nil)}
-      end
-      
-      @names[i]=value if i < size
-      
+  end
+
+  def set_key_at(i,value)
+    if @names.nil?
+      @names=Array.new
     end
-    
-    def keys
-      @names
+    if @names.size<size
+      (size-@names.size).times {@names.push(nil)}
     end
-    
-    def put(key,value)
-        puts "rlist.put(#{key},#{value})" if $DEBUG
-        if key.nil?
-          add(value)
-          return nil
-        end
-        if !@names.nil?
-          p=names.index(key)
-          if !p.nil?
-            return @names[p]=value
-          end
-        end
-        puts "add key and value" if $DEBUG
-        i=size      
-        @names=Array.new(i) if(@names.nil?)
-        @data.push(value)
-        @names.push(key)
-      
+
+    @names[i]=value if i < size
+
+  end
+
+  def keys
+    @names
+  end
+
+  def put(key,value)
+    puts "rlist.put(#{key},#{value})" if $DEBUG
+    if key.nil?
+      add(value)
+      return nil
     end
-    def add(a,b=nil)
-     if b.nil?
-       @data.push(a)
-       @names=Array.new(@data.size-1) if @names.nil?
-       @names.push(nil)
-      else
-        @data.insert(a,b)
-        @names.insert(a,nil)
+    if !@names.nil?
+      p=names.index(key)
+      if !p.nil?
+        return @names[p]=value
       end
     end
-    def clear
-      @data.clear
-      @names=nil
+    puts "add key and value" if $DEBUG
+    i=size
+    @names=Array.new(i) if(@names.nil?)
+    @data.push(value)
+    @names.push(key)
+
+  end
+  def add(a,b=nil)
+    if b.nil?
+      @data.push(a)
+      @names=Array.new(@data.size-1) if @names.nil?
+      @names.push(nil)
+    else
+      @data.insert(a,b)
+      @names.insert(a,nil)
     end
-    def clone
-      RList.new(@data,@names)
+  end
+  def clear
+    @data.clear
+    @names=nil
+  end
+  def clone
+    RList.new(@data,@names)
+  end
+  def remove(elem)
+    if elem.is_a? String
+      i=@data.index(elem)
+    elsif elem.is_a? Integer
+      i=elem
     end
-    def remove(elem)
-      if elem.is_a? String
-        i=@data.index(elem)
-      elsif elem.is_a? Integer
-        i=elem
-      end
-      return false if i.nil?
-      @data.delete_at(i)
-      @names.delete_at(i) unless @names.nil?
-      @names=nil if size==0
+    return false if i.nil?
+    @data.delete_at(i)
+    @names.delete_at(i) unless @names.nil?
+    @names=nil if size==0
+  end
+  # Returns data with appropiate ruby representation
+  def to_a
+    @data.map {|d|
+      d.to_ruby
+    }
+  end
+  # Returns recursively a hash or array:
+  # * Unnamed list: returns an Array
+  # * Named List: returns a Hash. Every element without explicit name receive
+  #   as key the number of element, 1-based
+  #
+
+  def to_ruby
+    if names.nil? or names.all? {|v| v.nil?}
+      to_a
+    else
+      h=Hash.new
+      names.each_with_index {|name,i|
+        key= (name=="" or name.nil?) ? i+1 : name
+        h[key]=@data[i].to_ruby
+      }
+      h
     end
   end
-end
+end
+end

data/lib/rserve/talk.rb

@@ -3,7 +3,7 @@ module Rserve
   #
   # I separated the 'abstract' aspect of the protocol on
   # Protocol module, for better testing
-  # 
+  #
   class Talk
     include Rserve::Protocol
     attr_reader :io
@@ -20,29 +20,29 @@ module Rserve
     # @param :len number of bytes in cont to send (it is clipped to the length of cont if necessary)
     # @return returned packet or <code>null</code> if something went wrong */
     def request(params=Hash.new)
-       
-        cmd     = params.delete :cmd
-        prefix  = params.delete :prefix
-        cont    = params.delete :cont
-        offset  = params.delete :offset
-        len     = params.delete :len
-        
-        if cont.is_a? String
-          cont=request_string(cont)
-        elsif cont.is_a? Integer
-          cont=request_int(cont)
-        end
-        raise ArgumentError, ":cont should be an Enumerable" if !cont.nil? and !cont.is_a? Enumerable
-        
-        if len.nil? 
-          len=(cont.nil?) ? 0 : cont.length
-        end
-        
-        offset||=0
-        
-      
-      if (!cont.nil?) 
-        if (offset>=cont.length) 
+
+      cmd     = params.delete :cmd
+      prefix  = params.delete :prefix
+      cont    = params.delete :cont
+      offset  = params.delete :offset
+      len     = params.delete :len
+
+      if cont.is_a? String
+        cont=request_string(cont)
+      elsif cont.is_a? Integer
+        cont=request_int(cont)
+      end
+      raise ArgumentError, ":cont should be an Enumerable" if !cont.nil? and !cont.is_a? Enumerable
+      if len.nil?
+        len=(cont.nil?) ? 0 : cont.length
+      end
+
+      offset||=0
+
+
+      if (!cont.nil?)
+        raise ":cont shouldn't contain anything but Fixnum" if cont.any? {|v| !v.is_a? Fixnum}
+        if (offset>=cont.length)
           cont=nil;len=0
         elsif (len>cont.length-offset)
           len=cont.length-offset
@@ -51,8 +51,8 @@ module Rserve
       offset=0 if offset<0
       len=0 if len<0
       contlen=(cont.nil?) ? 0 : len
-      contlen+=prefix.length if (!prefix.nil? and prefix.length>0) 
-      
+      contlen+=prefix.length if (!prefix.nil? and prefix.length>0)
+
       hdr=Array.new(16)
       set_int(cmd,hdr,0)
       set_int(contlen,hdr,4);
@@ -63,48 +63,48 @@ module Rserve
           io.write(prefix.pack("C*"))
           puts "SEND PREFIX #{prefix}" if $DEBUG
         end
-        if (!cont.nil? && cont.length>0)
-          io.write(cont.slice(offset, len).pack("C*")) 
-          puts "SEND CONTENT '#{cont.slice(offset, len).pack("C*")}'" if $DEBUG
+        if (!cont.nil? and cont.length>0)
+          puts "SEND CONTENT #{cont.slice(offset, len)} (#{offset},#{len})" if $DEBUG
+          io.write(cont.slice(offset, len).pack("C*"))
         end
       end
-        
-        ih=io.recv(16).unpack("C*")
-        
-        return nil if (ih.length!=16)
-        
-        puts "Answer: #{ih.to_s}" if $DEBUG
-        
-        rep=get_int(ih,0);
-        
-        rl =get_int(ih,4);
-        
-        if $DEBUG
-          puts "rep: #{rep} #{rep.class} #{rep & 0x00FFFFFF}"
-          puts "rl: #{rl} #{rl.class}"
-        end
-        
-        if (rl>0)
-          ct=Array.new();
-          n=0;
-          while (n<rl) do
-            data=io.recv(rl-n).unpack("C*")
-            ct+=data
-            rd=data.length
-            n+=rd;
-          end
-          
-          return Packet.new(rep,ct);
+      puts "Expecting 16 bytes..." if $DEBUG
+      ih=io.recv(16).unpack("C*")
+
+      return nil if (ih.length!=16)
+
+      puts "Answer: #{ih.to_s}" if $DEBUG
+
+      rep=get_int(ih,0);
+
+      rl =get_int(ih,4);
+
+      if $DEBUG
+        puts "rep: #{rep} #{rep.class} #{rep & 0x00FFFFFF}"
+        puts "rl: #{rl} #{rl.class}"
+      end
+
+      if (rl>0)
+        ct=Array.new();
+        n=0;
+        while (n<rl) do
+          data=io.recv(rl-n).unpack("C*")
+          ct+=data
+          rd=data.length
+          n+=rd;
         end
-        
-        return Packet.new(rep,nil);
+
+        return Packet.new(rep,ct);
+      end
+
+      return Packet.new(rep,nil);
     end
     def request_string(s)
       b=s.unpack("C*")
       sl=b.length+1;
       sl=(sl&0xfffffc)+4 if ((sl&3)>0)  # make sure the length is divisible by 4
       rq=Array.new(sl+5)
-      
+
       b.length.times {|i| rq[i+4]=b[i]}
       ((b.length)..sl).each {|i|
         rq[i+4]=0
@@ -114,8 +114,8 @@ module Rserve
     end
     def request_int(par)
       rq=Array.new(8)
-	    set_int(par,rq,4)
-	    set_hdr(DT_INT,4,rq,0)
+      set_int(par,rq,4)
+      set_hdr(DT_INT,4,rq,0)
       rq
     end
   end

data/spec/rserve_connection_spec.rb

@@ -1,34 +1,34 @@
 require File.dirname(__FILE__)+"/spec_helper.rb"
 describe Rserve::Connection do
-   describe "opening and closing" do
-     before do
-       @r=Rserve::Connection.new()
-     end
-     it "should be open a connection and receive ID-String" do
-       @r.get_server_version.should==103
-       @r.protocol.should=="QAP1"
-       @r.last_error.should=="OK"
-       @r.rt.should be_instance_of(Rserve::Talk)
-     end
-     it "should raise ServerNotAvailable if started another instance on another port" do
-       lambda {Rserve::Connection.new(:port_number=>6700)}.should raise_exception(Rserve::Connection::ServerNotAvailable)
-     end
-     it "should quit correctly" do
-       @r.should be_connected
-       @r.close.should be_true
-       @r.should_not be_connected
-       @r.close.should be_true
-     end
-     it "raise an error if eval is clased after closed" do
-       @r.close
-       lambda {@r.eval("TRUE")}.should raise_exception(Rserve::Connection::NotConnected)
-     end
-     after do
-       @r.close if @r.connected?
-     end
-   
- end
- describe "basic eval methods" do
+  describe "opening and closing" do
+    before do
+      @r=Rserve::Connection.new()
+    end
+    it "should be open a connection and receive ID-String" do
+      @r.get_server_version.should==103
+      @r.protocol.should=="QAP1"
+      @r.last_error.should=="OK"
+      @r.rt.should be_instance_of(Rserve::Talk)
+    end
+    it "should raise ServerNotAvailable if started another instance on another port" do
+      lambda {Rserve::Connection.new(:port_number=>6700)}.should raise_exception(Rserve::Connection::ServerNotAvailable)
+    end
+    it "should quit correctly" do
+      @r.should be_connected
+      @r.close.should be_true
+      @r.should_not be_connected
+      @r.close.should be_true
+    end
+    it "raise an error if eval is clased after closed" do
+      @r.close
+      lambda {@r.eval("TRUE")}.should raise_exception(Rserve::Connection::NotConnected)
+    end
+    after do
+      @r.close if @r.connected?
+    end
+
+  end
+  describe "basic eval methods" do
     before do
       @r=Rserve::Connection.new
     end
@@ -40,24 +40,90 @@ describe Rserve::Connection do
       lambda {@r.void_eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
       e.request_packet.stat.should==127}
     end
-    
+
     it "method eval should return a simple object" do
       la=@r.eval("TRUE")
       la.should be_instance_of(Rserve::REXP::Logical)
       la.true?.should==[true]
     end
-    
+
     it "method eval should raise an error with an incorrect expression" do
       lambda {@r.eval("x<-")}.should raise_exception(Rserve::Connection::EvalError) {|e| e.request_packet.stat.should==2}
       lambda {@r.eval("as.stt(c(1))")}.should raise_exception(Rserve::Connection::EvalError) {|e|
       e.request_packet.stat.should==127}
     end
-    
+
     it "should eval_void and eval correctly" do
       @r.void_eval("x<-c(TRUE,FALSE)").should be_true
       la=@r.eval("x")
       la.should be_instance_of(Rserve::REXP::Logical)
-      la.true?.should==[true,false]      
+      la.true?.should==[true,false]
+    end
+    it "should assign a string" do
+      @r.assign("x","a string")
+      @r.eval("x").to_ruby.should=="a string"
+    end
+
+  end
+  describe "assign using REXPs" do
+    before do
+      @r=Rserve::Connection.new
+
+    end
+    it "should assign double" do
+      rexp=Rserve::REXP::Double.new([1.5,-1.5])
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    
+    it "should assign a null" do
+      rexp=Rserve::REXP::Null.new
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a int vector" do
+      rexp=Rserve::REXP::Integer.new([1,2,3])
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a bool vector" do
+      rexp=Rserve::REXP::Logical.new([1,0,1])
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a string vector" do
+      rexp=Rserve::REXP::String.new(%w{a b c})
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a list without names" do
+      rexp=Rserve::REXP::GenericVector.new(Rserve::Rlist.new([Rserve::REXP::String.new("a")]))
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a list without names and nulls" do
+      rexp=Rserve::REXP::GenericVector.new(Rserve::Rlist.new([Rserve::REXP::Null.new]))
+      @r.assign("x", rexp)
+      @r.eval("x").should==rexp
+    end
+    it "should assign a list with names" do
+      x=@r.eval("list(a=TRUE)")
+      @r.assign("x",x)
+      @r.eval("x").should==x
+    end
+    it "should assign a data.frame" do
+      x=@r.eval("data.frame(a=rnorm(100),b=rnorm(100))")
+      @r.assign("x",x)
+      @r.eval("x").should==x
+    end
+    it "should assign a matrix" do
+      x=@r.eval("matrix(1:9,3,3)")
+      @r.assign("x",x)
+      @r.eval("x").should==x
+      
+    end
+    after do
+      @r.void_eval("rm(x)")
     end
   end
 end