rserve-client 0.1.5 → 0.1.6

data.tar.gz.sig

@@ -1,2 +1 @@
-A.���CTz�E�c��-�ˣmt��r�I���Y���>w��������:��_ܭA�Z��
y�a>�e����xX���_�A8�}��כ���5~~��C�,�p��r>��n�	_���˂�P���t��`F��Ʉ'���'���f��#	��M/��t�|�*�}F��U��\�{�� ������а�
-�|�5`[2�W���ڀl����!o�E!�s�O5�G�nB�x<Y̬�\5w 蛩�ɨ��
+`�~�i��N� �h�DNr�ZJ)C�-*ؔtt�|��ŽkR����
�OHn�B��u�y%@��O�=o��u���I��������	#Ͱp�����f�O����{���l)j?c�%{�p}ް�s���T3Ww��(*�@����^:kx�]yꋭ�EXvb/%��{������w%[���^�e���"��s#����q�A����A]�4F���2�{q�%��#�%oݤ
J>�b{o�%b���t	��

data/.gitignore

@@ -1,3 +1,4 @@
+coverage.info
 *~
 doc
 pkg

data/History.txt

@@ -1,11 +1,24 @@
+=== 0.1.6 / 2010-05-27
+* Assign complete for all commons REXPs
+* Added Connection#shutdown
+* Added arch dependent  for Double NA
+* Bug fix: list with booleans and NA raise an error
+* Added support for all types of REXP. 
+* REXP::Wrapper provides a method to convert ruby types to R types. 
+* Added spec for Rlist and REXP::Wrapper
+* Added generic to_ruby method. Ex.: Rlist#to_ruby returns an array
+* README.txt updated
+
+
 === 0.1.5 / 2010-05-24
 * Bug fix: Incorrect NA for Logical, String and Double Vector
 * Factors implemented
+* Correct Manifest.txt
 
 === 0.1.3 / 2010-05-24
 * Better README.txt
-* Implemented hash of options on Connection.new
-* Better implementation of errors on connections
+* Implemented options hash on Connection.new
+* Better implementation of errors on connection
 * REXP::Double#as_strings returns values as floats, not Rationals
 * Bug fix on REXP#as_double_matrix. 
 * Added REXP#as_matrix, which return a standard library matrix from a R matrix

data/Manifest.txt

@@ -12,6 +12,8 @@ lib/rserve/protocol.rb
 lib/rserve/protocol/rexpfactory.rb
 lib/rserve/rexp.rb
 lib/rserve/rexp/double.rb
+lib/rserve/rexp/environment.rb
+lib/rserve/rexp/expressionvector.rb
 lib/rserve/rexp/factor.rb
 lib/rserve/rexp/genericvector.rb
 lib/rserve/rexp/integer.rb
@@ -19,10 +21,14 @@ lib/rserve/rexp/language.rb
 lib/rserve/rexp/list.rb
 lib/rserve/rexp/logical.rb
 lib/rserve/rexp/null.rb
+lib/rserve/rexp/raw.rb
+lib/rserve/rexp/reference.rb
+lib/rserve/rexp/s4.rb
 lib/rserve/rexp/string.rb
 lib/rserve/rexp/symbol.rb
 lib/rserve/rexp/unknown.rb
 lib/rserve/rexp/vector.rb
+lib/rserve/rexp/wrapper.rb
 lib/rserve/rfactor.rb
 lib/rserve/rlist.rb
 lib/rserve/talk.rb
@@ -33,8 +39,10 @@ spec/rserve_logical_spec.rb
 spec/rserve_packet_spec.rb
 spec/rserve_protocol_spec.rb
 spec/rserve_rexp_spec.rb
+spec/rserve_rexp_wrapper_spec.rb
 spec/rserve_rexpfactory_spec.rb
 spec/rserve_rfactor_spec.rb
+spec/rserve_rlist_spec.rb
 spec/rserve_spec.rb
 spec/rserve_talk_spec.rb
 spec/spec.opts

data/README.txt

@@ -15,13 +15,17 @@ Follows closely the new Java client API, but maintains all Ruby conventions when
 * Uses TCP/IP sockets to interchange data and commands
 * Requires Rserve installed on the server machine. On debian /  ubuntu, you should use <tt>sudo apt-get install r-cran-rserve</tt>
 Pros:
-  * Work with Ruby 1.8, 1.9 and JRuby 1.5
+  * Work with Ruby 1.8, 1.9 and JRuby 1.5.
+  * Should work on Windows (not tested yet)
   * Implements almost completely R's datatypes: integer, doubles, chars, logical vectors, lists and raw data.
-  * Follows closely the Java API, so any change on the server could be adopted without much problem
+  * Follows closely the Java API, so any change on the server API could be adopted without much problem
   * Fast
+  * Easy management of differences between R and Ruby, or "You can have your cake and eat it, too!"
+    *  From R side: The evaluation of expression retrieves REXP object, with a lot of information from original variables on R. You can construct your REXP objects and <tt>assign</tt> them to variables on R fast using binary TCP/IP port or send complex expression without lost of time using <tt>void_eval</tt> 
+    * Between R and Ruby: Every REXP object implements methods to convert to specific Ruby type: as_integers, as_doubles, as_strings
+    * From Ruby side: Every REXP objects has a <tt>to_ruby</tt> method, which automagicly converts every R type on equivalent Ruby type. So, a vector of size 1 is converted to an integer or double, a vector of size>1 returns an array, a named list returns a hash and so on. If you need to create a complex expression, you could always use method <tt>eval</tt> without problem
 Cons:
   * Requires Rserve
-  * No seamless integration with Ruby. You obtain data with an interface closer to R than Ruby.
  
 == RELATED LIBRARIES (Ruby / R)
 
@@ -51,13 +55,6 @@ Cons:
 
 Implements
 
-* REXPs
-  * Enviroment
-  * ExpressionVector
-  * Raw
-  * Reference
-  * S4
-  * Wrapper
 * Sessions
 * Authentification
 * Original test
@@ -70,16 +67,41 @@ Spec
 
 == SYNOPSIS:
 
-  require 'rserve'
-  con=Rserve::Connection.new
-  con.eval("x<-rnorm(1)")
-  => #<Rserve::REXP::Double:0x000000011a13c8 
-        @payload=[(5339785585931699/2251799813685248)], 
-	@attr=nil>
-  con.eval("list(name='Fred')").as_list
-  
-  => #<Rserve::Rlist:0x00000001bf82a8 @names=["name"], @data=[#<Rserve::REXP::String:0x00000001bf8548 @payload=["Fred"], @attr=nil>]>
+    require 'rserve'
+    con=Rserve::Connection.new
+    
+    # Evaluation retrieves a <tt>Rserve::REXP</tt> object
+    
+    x=con.eval('x<-rnorm(1)')
+    => #<Rserve::REXP::Double:0x000000010a81f0 @payload=[(4807469545488851/9007199254740992)], @attr=nil>
 
+    # You could use specific methods to retrieve ruby objects
+    x.as_doubles => [0.533736337958596]
+    x.as_strings => ["0.533736337958596"]
+    
+    # Every Rserve::REXP could be converted to Ruby objects using
+    # method <tt>to_ruby</tt>
+    x.to_ruby => (4807469545488851/9007199254740992)
+    
+    # The API could manage complex recursive list
+    
+    x=con.eval('list(l1=list(c(2,3)),l2=c(1,2,3))').to_ruby
+    => {"l1"=>[[(2/1), (3/1)]], "l2"=>[(1/1), (2/1), (3/1)]}
+    
+    # You could assign a REXP to R variables
+
+    con.assign("x", Rserve::REXP::Double.new([1.5,2.3,5]))
+    => #<Rserve::Packet:0x0000000136b068 @cmd=65537, @cont=nil>
+    con.eval("x")
+    => #<Rserve::REXP::Double:0x0000000134e770 @payload=[(3/2), (2589569785738035/1125899906842624), (5/1)], @attr=nil>
+    
+    # Rserve::REXP::Wrapper.wrap allows you to transform Ruby object to 
+    # REXP, could be assigned to R variables
+    
+    Rserve::REXP::Wrapper.wrap(["a","b",["c","d"]])
+    
+    => #<Rserve::REXP::GenericVector:0x000000010c81d0 @attr=nil, @payload=#<Rserve::Rlist:0x000000010c8278 @names=nil, @data=[#<Rserve::REXP::String:0x000000010c86d8 @payload=["a"], @attr=nil>, #<Rserve::REXP::String:0x000000010c85c0 @payload=["b"], @attr=nil>, #<Rserve::REXP::String:0x000000010c82e8 @payload=["c", "d"], @attr=nil>]>>
+    
 == REQUIREMENTS:
 
 * R

data/lib/rserve.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.1.5'
+  VERSION = '0.1.6'
 end
 
 

data/lib/rserve/connection.rb

@@ -1,7 +1,7 @@
 module Rserve
   class Connection < Rserve::Engine
     include Rserve::Protocol
-    
+
     # :section: Exceptions
     RserveNotStarted=Class.new(Exception)
     ServerNotAvailable=Class.new(Exception)
@@ -18,7 +18,7 @@ module Rserve
     end
     attr_reader :hostname
     attr_reader :port_number
-    attr_reader :protocol 
+    attr_reader :protocol
     attr_reader :last_error
     attr_reader :connected
     attr_reader :auth_req
@@ -29,9 +29,10 @@ module Rserve
     attr_reader :port
     attr_writer :transfer_charset
     attr_reader :rsrv_version
+    attr_writer :persistent
     AT_plain=0
     AT_crypt=1
-    
+
     def initialize(opts=Hash.new)
       @auth_req         = opts.delete(:auth_req)          || false
       @transfer_charset = opts.delete(:transfer_charset)  || "UTF-8"
@@ -39,52 +40,53 @@ module Rserve
       @hostname         = opts.delete(:hostname)          || "127.0.0.1"
       @port_number      = opts.delete(:port_number)       || 6311
       @max_tries        = opts.delete(:max_tries)         || 5
-
       @tries            = 0
       @connected=false
-      
-      
-      begin 
+
+
+      begin
         #puts "Tryin to connect..."
         connect
       rescue Errno::ECONNREFUSED
         if @tries<@max_tries
-           @tries+=1
-           # Rserve is available?
-           if system "killall -s 0 Rserve"
-             # Rserve is available. Incorrect host and/or portname
-             raise ServerNotAvailable, "Rserve started, but not available on #{hostname}:#{port_number}"
-           # Rserve not available. We should instanciate it first
-           else 
-             if system "R CMD Rserve"
-             #puts "Ok"
-             retry
-              else
-                raise RserveNotStarted, "Can't start Rserve"
-              end
-           end
+          @tries+=1
+          # Rserve is available?
+          if system "killall -s 0 Rserve"
+            # Rserve is available. Incorrect host and/or portname
+            raise ServerNotAvailable, "Rserve started, but not available on #{hostname}:#{port_number}"
+            # Rserve not available. We should instanciate it first
+          else
+            if system "R CMD Rserve"
+              # Wait a moment please
+              sleep(0.25)
+              retry
+            else
+              raise RserveNotStarted, "Can't start Rserve"
+            end
+          end
           #puts "Init RServe"
-          
+
         else
           raise
         end
       end
     end
     def connect
-        close if @connected
-        @s = TCPSocket::new(@hostname, @port_number)
-        @rt=Rserve::Talk.new(@s)
-        #puts "Connected"
-        # Accept first input
-        input=@s.recv(32).unpack("a4a4a4a20")
-        raise IncorrectServer,"Handshake failed: Rsrv signature expected, but received [#{input[0]}]" unless input[0]=="Rsrv"
-        @rsrv_version=input[1].to_i
-        raise IncorrectServerVersion, "Handshake failed: The server uses more recent protocol than this client." if @rsrv_version>103
-        @protocol=input[2]
-        raise IncorrectProtocol, "Handshake failed: unsupported transfer protocol #{@protocol}, I talk only QAP1." if @protocol!="QAP1"
-        @extra=input[4]
-        @connected=true
-        @last_error="OK"
+      
+      close if @connected
+      @s = TCPSocket::new(@hostname, @port_number)
+      @rt=Rserve::Talk.new(@s)
+      #puts "Connected"
+      # Accept first input
+      input=@s.recv(32).unpack("a4a4a4a20")
+      raise IncorrectServer,"Handshake failed: Rsrv signature expected, but received [#{input[0]}]" unless input[0]=="Rsrv"
+      @rsrv_version=input[1].to_i
+      raise IncorrectServerVersion, "Handshake failed: The server uses more recent protocol than this client." if @rsrv_version>103
+      @protocol=input[2]
+      raise IncorrectProtocol, "Handshake failed: unsupported transfer protocol #{@protocol}, I talk only QAP1." if @protocol!="QAP1"
+      @extra=input[4]
+      @connected=true
+      @last_error="OK"
 
     end
     def connected?
@@ -102,10 +104,10 @@ module Rserve
     def get_server_version
       @rsrv_version
     end
-    
+
     # evaluates the given command, but does not fetch the result (useful for assignment operations)
     # * @param cmd command/expression string */
-    def void_eval(cmd) 
+    def void_eval(cmd)
       raise NotConnected if !connected? or rt.nil?
       rp=rt.request(:cmd=>Rserve::Protocol::CMD_voidEval, :cont=>cmd+"\n")
       if !rp.nil? and rp.ok?
@@ -113,43 +115,124 @@ module Rserve
       else
         raise EvalError.new(rp), "voidEval failed: #{rp.to_s}"
       end
-      
-    end
-    
-    
-  # evaluates the given command and retrieves the result
-  # * @param cmd command/expression string
-  # * @return R-xpression or <code>null</code> if an error occured */
-  def eval(cmd) 
-		raise NotConnected if !connected? or rt.nil?
-    rp=rt.request(:cmd=>Rserve::Protocol::CMD_eval, :cont=>cmd+"\n")
-    if !rp.nil? and rp.ok?
-      parse_eval_response(rp)
-    else
-      raise EvalError.new(rp), "voidEval failed: #{rp.to_s}"
+
     end
-  end
-  def parse_eval_response(rp)
-    rxo=0
-    pc=rp.cont
-    if (rsrv_version>100) # /* since 0101 eval responds correctly by using DT_SEXP type/len header which is 4 bytes long */
-			rxo=4
-			# we should check parameter type (should be DT_SEXP) and fail if it's not
-			if (pc[0]!=Rserve::Protocol::DT_SEXP && pc[0]!=(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
-				raise "Error while processing eval output: SEXP (type "+Rserve::Protocol::DT_SEXP+") expected but found result type "+pc[0].to_s+"."
-      end
-			if (pc[0]==(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
-				rxo=8; # large data need skip of 8 bytes
+
+
+    # evaluates the given command and retrieves the result
+    # * @param cmd command/expression string
+    # * @return R-xpression or <code>null</code> if an error occured */
+    def eval(cmd)
+      raise NotConnected if !connected? or rt.nil?
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_eval, :cont=>cmd+"\n")
+      if !rp.nil? and rp.ok?
+        parse_eval_response(rp)
+      else
+        raise EvalError.new(rp), "voidEval failed: #{rp.to_s}"
       end
-			# warning: we are not checking or using the length - we assume that only the one SEXP is returned. This is true for the current CMD_eval implementation, but may not be in the future. */
     end
-    if pc.length>rxo 
+
+    # NOT TESTED
+    def parse_eval_response(rp)
+      rxo=0
+      pc=rp.cont
+      if (rsrv_version>100) # /* since 0101 eval responds correctly by using DT_SEXP type/len header which is 4 bytes long */
+        rxo=4
+        # we should check parameter type (should be DT_SEXP) and fail if it's not
+        if (pc[0]!=Rserve::Protocol::DT_SEXP && pc[0]!=(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
+          raise "Error while processing eval output: SEXP (type "+Rserve::Protocol::DT_SEXP+") expected but found result type "+pc[0].to_s+"."
+        end
+        if (pc[0]==(Rserve::Protocol::DT_SEXP|Rserve::Protocol::DT_LARGE))
+          rxo=8; # large data need skip of 8 bytes
+        end
+        # warning: we are not checking or using the length - we assume that only the one SEXP is returned. This is true for the current CMD_eval implementation, but may not be in the future. */
+      end
+      if pc.length>rxo
         rx=REXPFactory.new;
-				rx.parse_REXP(pc, rxo);
-				return rx.get_REXP();
+        rx.parse_REXP(pc, rxo);
+        return rx.get_REXP();
       else
         return nil
+      end
+    end
+
+    #assign a string value to a symbol in R. The symbol is created if it doesn't exist already.
+    # @param sym symbol name. Currently assign uses CMD_setSEXP command of Rserve, i.e. the symbol value is NOT parsed. It is the responsibility of the user to make sure that the symbol name is valid in R (recall the difference between a symbol and an expression!). In fact R will always create the symbol, but it may not be accessible (examples: "bar\nfoo" or "bar$foo").
+    # @param ct contents
+    def assign(sym, ct)
+      raise NotConnected if !connected? or rt.nil?
+      case ct
+      when String
+        assign_string(sym,ct)
+      when REXP
+        assign_rexp(sym,ct)
+      else
+        raise "Should be String or REXP"
+      end
+    end
+    def assign_string(sym,ct)
+      symn = sym.unpack("C*")
+      ctn  = ct.unpack("C*")
+      sl=symn.length+1
+      cl=ctn.length+1
+      sl=(sl&0xfffffc)+4 if ((sl&3)>0)  # make sure the symbol length is divisible by 4
+      cl=(cl&0xfffffc)+4 if ((cl&3)>0)  # make sure the content length is divisible by 4
+      rq=Array.new(sl+4+cl+4)
+      symn.length.times {|i| rq[i+4]=symn[i]}
+      ic=symn.length
+      while (ic<sl)
+        rq[ic+4]=0
+        ic+=1
+      end
+      ctn.length.times {|i| rq[i+sl+8]=ctn[i]}
+      ic=ctn.length
+      while (ic<cl)
+        rq[ic+sl+8]=0
+        ic+=1
+      end
+      set_hdr(Rserve::Protocol::DT_STRING,sl,rq,0)
+      set_hdr(Rserve::Protocol::DT_STRING,cl,rq,sl+4)
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_setSEXP,:cont=>rq)
+      if (!rp.nil? and rp.ok?)
+        rp
+      else
+        raise "Assign Failed"
+      end
+    end
+    def assign_rexp(sym, rexp)
+      r = REXPFactory.new(rexp);
+      rl=r.get_binary_length();
+      symn=sym.unpack("C*");
+      sl=symn.length+1;
+      sl=(sl&0xfffffc)+4 if ((sl&3)>0) # make sure the symbol length is divisible by 4
+      rq=Array.new(sl+rl+((rl>0xfffff0) ? 12 : 8));
+      symn.length.times {|i| rq[i+4]=symn[i]}
+      ic=symn.length
+      while(ic<sl)
+        rq[ic+4]=0;
+        ic+=1;
+      end # pad with 0
+
+      set_hdr(Rserve::Protocol::DT_STRING,sl,rq,0)
+      set_hdr(Rserve::Protocol::DT_SEXP,rl,rq,sl+4);
+      r.get_binary_representation(rq, sl+((rl>0xfffff0) ? 12 : 8));
+      # puts "ASSIGN RQ: #{rq}" if $DEBUG
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_setSEXP, :cont=>rq)
+      if (!rp.nil? and rp.ok?)
+        rp
+      else
+        raise "Assign Failed"
+      end
+    end
+    def shutdown
+      raise NotConnected if !connected? or rt.nil?
+      rp=rt.request(:cmd=>Rserve::Protocol::CMD_shutdown)
+      if !rp.nil? and rp.ok? 
+        true
+      else
+        raise "Shutdown failed"
+      end
     end
+        
   end
 end
-end