rserve-client 0.1.5 → 0.1.6

data/spec/rserve_double_spec.rb

@@ -12,11 +12,29 @@ describe Rserve::REXP::Double do
       a=Rserve::REXP::Double.new(payload)
       a.payload.should==[1.1]
     end
-    
-    
-    
+
+
+
+  end
+  describe "NA management" do
+    before do
+      @payload=[3,5,Rserve::REXP::Double::NA, 10,20]
+      @a=Rserve::REXP::Double.new(@payload)
+    end
+
+    it "method na? should return coherent answer" do
+      @a.na?(@a.as_integers[0]).should be_false
+      @a.na?(@a.as_integers[2]).should be_true
+      @a.na?.should==[false,false,true,false,false]
+    end
+    it "to_a should return correct values with NA" do
+      @a.to_a.should==[3,5, nil, 10, 20]
+    end
+    it "to_ruby should return correct values with NA" do
+      @a.to_ruby.should==[3,5, nil, 10, 20]
+    end
   end
-    describe "common methods" do
+  describe "common methods" do
     before do
       @n=rand(10)+10
       @payload=@n.times.map {rand(10).to_f}
@@ -37,19 +55,14 @@ describe Rserve::REXP::Double do
     it "method as_strings should return strings" do
       @a.as_strings.should==@payload.map(&:to_s)
     end
-    it "method na? should return coherent answer" do
-      payload=[3,5,Rserve::REXP::Double::NA, 10,20]
-      a=Rserve::REXP::Double.new(payload)
-      a.na?(a.as_integers[0]).should be_false
-      a.na?(a.as_integers[2]).should be_true
-      a.na?.should==[false,false,true,false,false]
-    end
+
+
     it "method to_debug_string and to_s returns a coherent response" do
       @a.to_debug_string.size.should>0
       @a.to_s.size.should>0
-      
-    end
+
     end
-  
-  
+  end
+
+
 end

data/spec/rserve_integer_spec.rb

@@ -12,11 +12,26 @@ describe Rserve::REXP::Integer do
       a=Rserve::REXP::Integer.new(payload)
       a.payload.should==[1]
     end
-    
-    
-    
+
+
+
+  end
+  describe "NA management" do
+    before do
+      @payload=[3,5,Rserve::REXP::Integer::NA, 10,20]
+      @a=Rserve::REXP::Integer.new(@payload)
+
+    end
+    it "method is_NA should return coherent answer" do
+      @a.na?(@a.as_integers[0]).should be_false
+      @a.na?(@a.as_integers[2]).should be_true
+      @a.na?.should==[false,false,true,false,false]
+    end
+    it "to_a should return correct values with NA" do
+      @a.to_a.should==[3,5, nil, 10, 20]
+    end
   end
-    describe "common methods" do
+  describe "common methods" do
     before do
       @n=rand(10)+10
       @payload=@n.times.map {rand(10)}
@@ -37,19 +52,13 @@ describe Rserve::REXP::Integer do
     it "method as_string should return string" do
       @a.as_strings.should==@payload.map(&:to_s)
     end
-    it "method is_NA should return coherent answer" do
-      payload=[3,5,Rserve::REXP::Integer::NA, 10,20]
-      a=Rserve::REXP::Integer.new(payload)
-      a.na?(a.as_integers[0]).should be_false
-      a.na?(a.as_integers[2]).should be_true
-      a.na?.should==[false,false,true,false,false]
-    end
+
     it "method to_debug_string and to_s returns a coherent response" do
       @a.to_debug_string.size.should>0
       @a.to_s.size.should>0
-      
-    end
+
     end
-  
-  
+  end
+
+
 end

data/spec/rserve_logical_spec.rb

@@ -13,7 +13,22 @@ describe Rserve::REXP::Integer do
       a.payload.should==[ Rserve::REXP::Logical::TRUE ]
     end
   end
-    describe "common methods" do
+  describe "NA management" do
+    before do
+      @payload=[1,Rserve::REXP::Logical::NA, 0]
+      @a=Rserve::REXP::Logical.new(@payload)
+
+    end
+    it "method is_NA should return coherent answer" do
+      @a.na?.should==[false,true,false]
+      @a.na?(@a.as_bytes[0]).should be_false
+      @a.na?(@a.as_bytes[1]).should be_true
+    end
+    it "method to_a should return correct answer" do
+      @a.to_a.should==[true,nil,false]
+    end
+  end
+  describe "common methods" do
     before do
       @n=rand(100)
       @payload=@n.times.map {rand(2)}
@@ -43,19 +58,13 @@ describe Rserve::REXP::Integer do
       @a.false?.should==@payload.map {|v| v==Rserve::REXP::Logical::FALSE ? true :false}
     end
 
-    it "method is_NA should return coherent answer" do
-      payload=[1,Rserve::REXP::Logical::NA, 0]
-      a=Rserve::REXP::Logical.new(payload)
-      a.na?.should==[false,true,false]
-      a.na?(a.as_bytes[0]).should be_false
-      a.na?(a.as_bytes[1]).should be_true
-    end
+
     it "method to_debug_string and to_s returns a coherent response" do
       @a.to_debug_string.size.should>0
       @a.to_s.size.should>0
-      
-    end
+
     end
-  
-  
+  end
+
+
 end

data/spec/rserve_protocol_spec.rb

@@ -24,15 +24,15 @@ describe Rserve::Protocol do
   end
   it "set_hdr method should set correctly the header for len>0xFFFFFF" do
     bytes=[0]*8
-    cmd=Rserve::Protocol::CMD_login    
+    cmd=Rserve::Protocol::CMD_login
     len=0x12345678
     offset=0
     expected=[cmd|Rserve::Protocol::DT_LARGE,0x78,0x56,0x34,0x12,0,0,0]
     @t.set_hdr(cmd,len,bytes,offset)
     bytes.should==expected
-  end 
+  end
   it "new_hdr method should return a correct header for different lengths" do
-    cmd=Rserve::Protocol::CMD_login    
+    cmd=Rserve::Protocol::CMD_login
     len=0x123456
     expected=[cmd,0x56,0x34,0x12]
     @t.new_hdr(cmd,len).should==expected
@@ -44,15 +44,15 @@ describe Rserve::Protocol do
     buffer=[0xFF,0x78,0x56,0x34,0x12]
     expected=0x12345678
     @t.get_int(buffer,1).should==expected
-    
+
     # Version with errors
-    
+
     buffer=[0xFF,0xFF78,0xFF56,0xFF34,0xFF12]
     expected=0x12345678
     @t.get_int(buffer,1).should==expected
   end
   it "get_len method should return correct length from a header" do
-     cmd=Rserve::Protocol::CMD_login    
+    cmd=Rserve::Protocol::CMD_login
     len=0x12345678
     header=@t.new_hdr(cmd,len)
     @t.get_len(header,0).should==len
@@ -71,5 +71,5 @@ describe Rserve::Protocol do
     expected=[0x45,0xDF,0xBC,0x9A,0x78,0x56,0x34,0x12]
     buffer.slice(1,8).should==expected
   end
-  
+
 end

data/spec/rserve_rexp_spec.rb

@@ -43,10 +43,10 @@ describe Rserve::REXP do
     it "method has_attribute? should return false for non existing value" do
       @l.has_attribute?('at2').should be_false
     end
-    it "method get_attrivute should return correct value for attribute" do
+    it "method get_attribute should return correct value for attribute" do
       @l.get_attribute('names').as_strings.should==['at']
     end
-    
+
   end
-  
+
 end

data/spec/rserve_rexp_wrapper_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe Rserve::REXP::Wrapper do
+  it "should wrap single value" do
+    Rserve::REXP::Wrapper.wrap(1).should==Rserve::REXP::Integer.new(1)
+    Rserve::REXP::Wrapper.wrap(1.0).should==Rserve::REXP::Double.new(1.0)
+    Rserve::REXP::Wrapper.wrap(true).should==Rserve::REXP::Logical.new(1)
+    Rserve::REXP::Wrapper.wrap("a").should==Rserve::REXP::String.new("a")
+  end
+  it "should wrap arrays of a single type" do
+    Rserve::REXP::Wrapper.wrap([1,2]).should==Rserve::REXP::Integer.new([1,2])
+    Rserve::REXP::Wrapper.wrap([1.0,2]).should==Rserve::REXP::Double.new([1.0,2.0])
+    Rserve::REXP::Wrapper.wrap([true,false]).should==Rserve::REXP::Logical.new([1,0])
+    Rserve::REXP::Wrapper.wrap(["a","b"]).should==Rserve::REXP::String.new(["a","b"])
+  end
+  it "should wrap on a list mixed values" do
+    r=Rserve::Connection.new
+    Rserve::REXP::Wrapper.wrap([1,2.0,false,"a"]).should==
+    Rserve::REXP::GenericVector.new(
+    Rserve::Rlist.new([
+      Rserve::REXP::Integer.new(1),
+      Rserve::REXP::Double.new(2.0),
+      Rserve::REXP::Logical.new(0),
+      Rserve::REXP::String.new("a"),
+
+    ])
+    )
+  end
+  it "should wrap arrays with nil values using NA values of specific type" do
+    Rserve::REXP::Wrapper.wrap([1,nil]).should==Rserve::REXP::Integer.new([1,Rserve::REXP::Integer::NA])
+    Rserve::REXP::Wrapper.wrap([1.0,nil]).should==Rserve::REXP::Double.new([1.0,Rserve::REXP::Double::NA])
+    Rserve::REXP::Wrapper.wrap([true,nil]).should==Rserve::REXP::Logical.new([1,Rserve::REXP::Logical::NA])
+    Rserve::REXP::Wrapper.wrap(["a",nil]).should==Rserve::REXP::String.new(["a", Rserve::REXP::String::NA])
+  end
+
+end

data/spec/rserve_rexpfactory_spec.rb

@@ -6,11 +6,20 @@ describe Rserve::Protocol::REXPFactory do
   before do
     @r=Rserve::Connection.new
   end
+  it "should process null" do
+    la=@r.eval("NULL")
+    la.should be_instance_of(Rserve::REXP::Null)
+  end
   it "should process single logical" do
     la=@r.eval("TRUE")
     la.should be_instance_of(Rserve::REXP::Logical)
     la.true?.should==[true]
   end
+  it "should process array" do
+    @r.void_eval("a<-c(1,2,3,4,5,6,7,8); attr(a,'dim')<-c(2,2,2)")
+    la=@r.eval("a")
+    la.dim.should==[2,2,2]
+  end
   it "should process logical vector" do
     la=@r.eval("c(TRUE,FALSE,TRUE)")
     la.should be_instance_of(Rserve::REXP::Logical)
@@ -19,7 +28,7 @@ describe Rserve::Protocol::REXPFactory do
   it "should process logical vectors with NA" do
     la=@r.eval("c(TRUE,NA)")
     la.should be_instance_of(Rserve::REXP::Logical)
-    la.na?.should==[false,true]    
+    la.na?.should==[false,true]
   end
   it "should process single double" do
     la=@r.eval("1.5")
@@ -30,7 +39,7 @@ describe Rserve::Protocol::REXPFactory do
     a=100.times.map{|i| rand()}
     la=@r.eval("c("+a.map(&:to_s).join(",")+")")
     la.should be_instance_of(Rserve::REXP::Double)
-    
+    la.dim.should be_nil
     la.as_doubles.map(&:to_f).each_with_index {|v,i|
       v.should be_close(a[i],1e-10)
     }
@@ -39,7 +48,7 @@ describe Rserve::Protocol::REXPFactory do
     la=@r.eval("c(1,NA)")
     la.should be_instance_of(Rserve::REXP::Double)
     la.na?.should==[false,true]
-    
+
   end
   it "should process string vector" do
     la=@r.eval("c('abc','def','ghi')")
@@ -52,27 +61,84 @@ describe Rserve::Protocol::REXPFactory do
     la.na?.should==[false,false,true]
 
   end
-  it "should process factor" do
-    la=@r.eval <<-EOF
-    state <- c("tas", "sa",  "qld", "nsw", "nsw", "nt",  "wa",  "wa",
-                  "qld", "vic", "nsw", "vic", "qld", "qld", "sa",  "tas",
-                  "sa",  "nt",  "wa",  "vic", "qld", "nsw", "nsw", "wa",
-                  "sa",  "act", "nsw", "vic", "vic", "act");
-    statef <- factor(state)
-    EOF
-    la.should be_factor
-    la.as_factor.levels.sort.should==%w{act nsw nt  qld sa tas vic wa}.sort
-
-    la.as_factor.contains?("tas").should be_true
-    la.as_factor.contains?("nn").should be_false
+  describe "factor processing" do
+    it "should process factor without NA" do
+      la=@r.eval <<-EOF
+      state <- c("tas", "sa",  "qld", "nsw", "nsw", "nt",  "wa",  "wa",
+      "qld", "vic", "nsw", "vic", "qld", "qld", "sa",  "tas",
+      "sa",  "nt",  "wa",  "vic", "qld", "nsw", "nsw", "wa",
+      "sa",  "act", "nsw", "vic", "vic", "act");
+      statef <- factor(state)
+      EOF
+      la.should be_factor
+      la.as_factor.levels.sort.should==%w{act nsw nt  qld sa tas vic wa}.sort
 
+      la.as_factor.contains?("tas").should be_true
+      la.as_factor.contains?("nn").should be_false
+      @r.void_eval("rm(state, statef)")
+    end
+    it "should process factors with NA" do
+      @r.void_eval "other<-c('a','a','b','b',NA)"
+      la=@r.eval("factor(other)")
+      la.as_strings.should==['a','a','b','b',nil]
+      la.as_factor.levels.sort.should==['a','b']
+    end
   end
-  it "should process list" do
-    require 'pp'
-    la=@r.eval("list(name='Fred',age=30,10,20,kids=c(1,2,3))")
+  it "should process basic list" do
+    la=@r.eval("list(first.name='Fred')")
     la.should be_list
     la.should be_recursive
-    la.as_list.names.should==['name','age','','','kids']
+    la.should==Rserve::REXP::GenericVector.new(
+    Rserve::Rlist.new([Rserve::REXP::String.new('Fred')], ["first.name"]),
+    Rserve::REXP::List.new(
+    Rserve::Rlist.new([Rserve::REXP::String.new('first.name')],['names'])
+    )
+    )
+    la.as_list.names.should==['first.name']
+  end
+
+  it "should process list with booleans and NA" do
+    la=@r.eval("list(TRUE)")
+    la.should be_true
+    la=@r.eval("list(2,NA)")
+    la.should be_true
+  end
+  it "should retrieve correct lenght for string" do
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new("a")).get_binary_length.should==8
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new(["a","b"])).get_binary_length.should==8
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new(["aaaa"])).get_binary_length.should==12
+
+  end
+  it "should retrieve correct representation for string" do
+    buf=[nil]*8
+    off=0
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new("a")).get_binary_representation(buf,off)
+    buf[4,4].should==[97,0,1,1]
+    buf.size.should==8
+    buf=[nil]*8
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new(["a","b"])).get_binary_representation(buf,off)
+    buf[4,8].should==[97,0,98,0]
+    buf.size.should==8
+
+    buf=[nil]*12
+    Rserve::Protocol::REXPFactory.new(Rserve::REXP::String.new("aaaa")).get_binary_representation(buf,off)
+    buf[4,8].should==[97,97,97,97,0,1,1,1]
+    buf.size.should==12
+  end
+  it "should retrieve correct binary representation for Symbol" do
+    rexp=Rserve::REXP::Symbol.new('names')
+    buf=Array.new(Rserve::Protocol::REXPFactory.new(rexp).get_binary_length)
+    Rserve::Protocol::REXPFactory.new(rexp).get_binary_representation(buf,0)
+    buf.should_not include(nil)
+  end
+
+  it "should retrieve correct binary representation for List" do
+    
+    rexp=Rserve::REXP::List.new(Rserve::Rlist.new([Rserve::REXP::String.new("a")], ["names"]));
+    buf=Array.new(Rserve::Protocol::REXPFactory.new(rexp).get_binary_length)
+    
+    Rserve::Protocol::REXPFactory.new(rexp).get_binary_representation(buf,0)
+    buf.should_not include(nil)
   end
 
 end

data/spec/rserve_rfactor_spec.rb

@@ -16,7 +16,7 @@ describe Rserve::RFactor do
       @factor[1].should=='a'
       @factor[3].should=='b'
       @factor[5].should=='c'
-      
+
     }
   end
   it "methods contains? should work with integers and strings" do
@@ -41,5 +41,5 @@ describe Rserve::RFactor do
   it "method as_strings should return correct values" do
     @factor.as_strings==%w{a a b b c c d}
   end
-  
+
 end

data/spec/rserve_rlist_spec.rb

@@ -0,0 +1,53 @@
+require File.dirname(__FILE__)+"/spec_helper.rb"
+
+describe Rserve::Rlist do
+  before do
+    @r=Rserve::Connection.new
+    @l=@r.eval("list(name='Fred',age=30,10,20,kids=c(1,2,3))").as_list
+  end
+  it "method names return correct names" do
+    @l.names.should==['name','age',"","","kids"]
+  end
+  it "method == should return true for rlist with equal data and names" do
+    a=Rserve::Rlist.new([1,2,3],%w{a b c})
+    b=Rserve::Rlist.new([1,2,3],%w{a b c})
+    (a==b).should be_true
+    a=Rserve::Rlist.new([1,2,3],%w{a b c})
+    b=Rserve::Rlist.new([1,2,3])
+    (a==b).should be_false
+    a=Rserve::Rlist.new([1,2,3],%w{a b c})
+    b=Rserve::Rlist.new([4,5,6],%w{c d e})
+    (a==b).should be_false
+
+  end
+  it "method [] return correct values for strings" do
+    @l['name'].to_ruby.should=='Fred'
+    @l['age'].to_ruby.should==30
+    @l['kids'].to_ruby.should==[1,2,3]
+  end
+  it "method [] return correct values for integers (0-based)" do
+    @l[2].to_ruby.should==10
+    @l[3].to_ruby.should==20
+  end
+  it "method to_a return an array with best ruby representation of data" do
+    @l.to_a.should==['Fred',30,10,20,[1,2,3]]
+  end
+  it "method to_ruby returns a hash when all names are set" do
+    list=@r.eval("list(name='Fred', age=30)")
+    list.to_ruby.should=={'name'=>'Fred','age'=>30}
+  end
+  it "method to_ruby returns a hash with numbers (1-based) replacing empty names" do
+    list=@r.eval("list(name='Fred', age=30,'aaaa')")
+    list.to_ruby.should=={'name'=>'Fred','age'=>30,3=>'aaaa'}
+  end
+  it "method to_ruby returns an array when no names are set" do
+    list=@r.eval("list(10,20,30)")
+    list.to_ruby.should==[10,20,30]
+  end
+  it "should allow recursive list" do
+    list=@r.eval("list(l1=list(l11=1,l22=2),l2=list(3,4))").as_list
+    list['l1'].to_ruby.should=={'l11'=>1,'l22'=>2}
+    list['l2'].to_ruby.should==[3,4]
+
+  end
+end