rserve-client 0.1.8 → 0.1.9

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -1,3 +1,20 @@
+=== 0.1.9 / 2010-06-04
+
+* Documentation:
+ * Added commentaries on examples/regression.txt
+ * Examples.txt on main directory renamed to Introduction.txt
+ * Added examples extracted from RinRuby documentation, adapted to rserve-client. Modified Connection#assign to allow ruby objects
+ * Modified lowless example, omiting use of Rserve::REXP::Wrapper
+* Bug fixes:
+  * WithNames#put changes names, not values. 
+  * Negative integer conversion works on i686 and x86_64 
+* New features
+  * Added WithNames[]= method for key assign. 
+  * Correct handling of data.frames with to_ruby : row.names returned as a array of (1..x) value if [NA,-x] returned from Rserve
+  * REXP#to_ruby returns object extended with WithAttributes and WithNames when applicable
+  * REXP could process nested arrays properly
+
+
 === 0.1.8 / 2010-06-01
 
 * Bug fix: attributes for generic vectors (data.frames) stored correctly. A Double vector without attribute dim raises an error on #to_ruby

data/{Examples.txt → Introduction.txt}

@@ -1,5 +1,4 @@
-= Examples for Rserve
-
+= Introduction to Ruby Rserve Client
 <em>Based on original Java version [http://www.rforge.net/Rserve/example.html]</em>
 
 Rserve itself is provided as a regular R package and can be installed as such. The actual use is not performed by the library command, but by starting the Rserve executable (Windows) or typing R CMD Rserve on the command line (all others). By default Rserve runs in local mode with no enforced authentication. Once the Rserve is running any applications can use its services.
@@ -16,15 +15,15 @@ The code has the same effect as typing R.version.string in R. In the first line
 
 The following code fragment illustrates the use of slightly more complex native Ruby types:
 
-  d = c.eval("rnorm(100)").as_doubles
+  d = c.eval("rnorm(100)").as_floats
 
 
-The single line in Ruby provides an array of 100 doubles representing random numbers from the standard normal distribution. The numeric vector in R is automatically converted into an array of floats. In cases where no native Ruby type exists, Rserve Ruby client defines its own classes such as Rlist or Logical (Ruby's boolean type has no support for NA missing values, therefore it cannot be used to directly represent logical type in R). This approach makes the use of Rserve very easy. As a first more practical example we want to calculate a Lowess smoother through a given set of points. The Ruby application lets the user specify the data allowing interactive changes of the points, displays a regular scatter plot and needs coordinates of the smoother to be obtained from R. One way of obtaining such a result would be to construct a long string command of the form lowes(c(0.2,0.4,...), c(2.5,4.8,...)) and using the eval method to obtain the result. This is somewhat clumsy, because the points usually already exist in an array in the Ruby application and the command string must be constructed from these. An alternative involves constructing objects in R directly. The following code shows the full Lowess example:
+The single line in Ruby provides an array of 100 ruby floats (double precision, on C) representing random numbers from the standard normal distribution. The numeric vector in R is converted into an array of floats. In cases where no native Ruby type exists, Rserve Ruby client defines its own classes such as Rlist or Logical (Ruby's boolean type has no support for NA missing values, therefore it cannot be used to directly represent logical type in R). This approach makes the use of Rserve very easy. As a first more practical example we want to calculate a Lowess smoother through a given set of points. The Ruby application lets the user specify the data allowing interactive changes of the points, displays a regular scatter plot and needs coordinates of the smoother to be obtained from R. One way of obtaining such a result would be to construct a long string command of the form lowes(c(0.2,0.4,...), c(2.5,4.8,...)) and using the eval method to obtain the result. This is somewhat clumsy, because the points usually already exist in an array in the Ruby application and the command string must be constructed from these. An alternative involves constructing objects in R directly. The following code shows the full Lowess example:
 
     require 'rserve'
     
-    data_x=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
-    data_y=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+    data_x=10.times.map{|i| rand(i)}
+    data_y=10.times.map{|i| rand(i)}
     c = Rserve::Connection.new();
     c.assign("x", data_x);
     c.assign("y", data_y);

data/Manifest.txt

@@ -1,10 +1,14 @@
-Examples.txt
+.autotest
 History.txt
+Introduction.txt
 Manifest.txt
 README.txt
 Rakefile
+data/gettysburg.txt
+examples/gettysburg.rb
 examples/hello_world.rb
 examples/lowless.rb
+examples/regression.rb
 lib/rserve.rb
 lib/rserve/connection.rb
 lib/rserve/engine.rb

data/data/gettysburg.txt

@@ -0,0 +1,25 @@
+THE GETTYSBURG ADDRESS:
+
+Four score and seven years ago our fathers brought forth on this
+continent a new nation, conceived in liberty and dedicated to the
+proposition that all men are created equal. Now we are engaged in
+a great civil war, testing whether that nation or any nation so
+conceived and so dedicated can long endure. We are met on a great
+battlefield of that war. We have come to dedicate a portion of
+that field as a final resting-place for those who here gave their
+lives that that nation might live. It is altogether fitting and
+proper that we should do this. But in a larger sense, we cannot
+dedicate, we cannot consecrate, we cannot hallow this ground.
+The brave men, living and dead who struggled here have consecrated
+it far above our poor power to add or detract. The world will
+little note nor long remember what we say here, but it can never
+forget what they did here. It is for us the living rather to be
+dedicated here to the unfinished work which they who fought here
+have thus far so nobly advanced. It is rather for us to be here
+dedicated to the great task remaining before us--that from these
+honored dead we take increased devotion to that cause for which
+they gave the last full measure of devotion--that we here highly
+resolve that these dead shall not have died in vain, that this
+nation under God shall have a new birth of freedom, and that
+government of the people, by the people, for the people shall
+not perish from the earth.

data/examples/gettysburg.rb

@@ -0,0 +1,24 @@
+# The code and output below demonstrates some of the Ruby Rserve client, using a example from RinRuby. Ruby code counts the number of occurences of each word in Lincoln's Gettysburg Address and filters out those occurring less than three times or shorter than four letters. R code -- through the Rserve library -- produces a bar plot of the most frequent words and computes the correlation between the length of a word and the usage frequency. Finally, the computed correlation is printed by Ruby
+
+require "rserve"
+r=Rserve::Connection.new
+
+ tally = Hash.new(0)
+ File.open(File.dirname(__FILE__)+'/../data/gettysburg.txt').each_line do |line|
+    line.downcase.split(/\W+/).each { |w| tally[w] += 1 }
+ end
+ total = tally.values.inject { |sum,count| sum + count }
+ tally.delete_if { |key,count| count < 3 || key.length < 4 }
+ 
+ r.assign("keys",tally.keys)
+ r.assign("counts", tally.values)
+       
+ r.void_eval <<-EOF
+    names(counts) <- keys
+    barplot(rev(sort(counts)),main="Frequency of Non-Trivial Words",las=2)
+    mtext("Among the #{total} words in the Gettysburg Address",3,0.45)
+    rho <- round(cor(nchar(keys),counts),4)
+EOF
+puts "Press enter when finished"
+STDIN.gets
+puts "The correlation between word length and frequency is #{r.eval("rho").as_float}."

data/examples/lowless.rb

@@ -1,7 +1,7 @@
 require 'rserve'
 
-data_x=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
-data_y=Rserve::REXP::Wrapper.wrap(10.times.map{|i| rand(i)})
+data_x=20.times.map{|i| rand(i)}
+data_y=20.times.map{|i| rand(i)}
 c = Rserve::Connection.new();
 c.assign("x", data_x);
 c.assign("y", data_y);

data/examples/regression.rb

@@ -0,0 +1,44 @@
+# As another example of Ruby Rserve client, extracted from RinRuby documentation, consider the usage of Ruby Rserve client for simple linear regression below. The simulation parameters are defined in Ruby, computations are performed in R, and Ruby reports the results. In a more eloborate application, the simulation parameter might come from input from a graphical user interface, the statistical analysis might be more involved, and the results might be an HTML page or PDF report.
+
+require 'rserve'
+r=Rserve::Connection.new
+n = 10
+beta_0 = 1
+beta_1 = 0.25
+alpha = 0.05
+seed = 23423
+
+# You could assign a ruby object to a R variable automaticly. You could see 
+# the rules of translation on Rserve::REXP::Wrapper module 
+r.assign "x", (1..n).entries
+
+# Rserve::Connection.void_eval allows you to send complex R commands
+# without wasting time retrieving the final result
+
+r.void_eval <<EOF
+ set.seed(#{seed})
+ y <- #{beta_0} + #{beta_1}*x + rnorm(#{n})
+ fit <- lm( y ~ x )
+ est <- round(coef(fit),3)
+ pvalue <- summary(fit)$coefficients[2,4]
+EOF
+
+# Rserve::Connecttion.eval retrieve a Rserve::REXP object, which could
+# be translated to an appropiate Ruby object using Rserve::REXP.to_ruby method
+#
+est=r.eval("est").to_ruby
+
+# fit$coef is a named doubles vector, so the respective Ruby object is an
+# array of rational extended with module WithNames. That allows us
+# to retrieve every element of the vector by its name
+
+puts "E(y|x) ~= #{est['(Intercept)'].to_f} + #{est['x'].to_f} * x"
+
+# fit$pvalue is a vector of size 1. So, the method #to_ruby
+# retrieves a rational or a Fixnum, according to original representation
+
+if r.eval("pvalue").to_ruby < alpha
+ puts "Reject the null hypothesis and conclude that x and y are related."
+else
+ puts "There is insufficient evidence to conclude that x and y are related."
+end

data/lib/rserve.rb

@@ -1,7 +1,7 @@
 require 'socket'
 
 module Rserve
-  VERSION = '0.1.8'
+  VERSION = '0.1.9'
 end
 
 

data/lib/rserve/connection.rb

@@ -167,7 +167,7 @@ module Rserve
       when REXP
         assign_rexp(sym,ct)
       else
-        raise "Should be String or REXP"
+        assign_rexp(sym, Rserve::REXP::Wrapper.wrap(ct))
       end
     end
     def assign_string(sym,ct)

data/lib/rserve/protocol.rb

@@ -110,7 +110,9 @@ module Rserve
       ERR_session_busy=>"session still busy",
       ERR_detach_failed=>"unable to detach seesion"
     } # error descriptions
-
+    # I have to use to support different archs
+    MAX_LONG_SIGNED=2**31
+    MAX_LONG_UNSIGNED=2**32
 
     # writes bit-wise int to a byte buffer at specified position in Intel-endian form
     # Internal: byte buffer will be the result of unpack("CCCC") an integer.
@@ -160,8 +162,9 @@ module Rserve
     # make sure that the buffer is big enough
 
     def get_int(buf, o)
-      #return buf.slice(o,4).pack("C*").unpack("i")[0]
-      return ((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24));
+      #return buf.slice(o,4).pack("C*").unpack("l")[0]
+      v=((buf[o]&255)|((buf[o+1]&255)<<8)|((buf[o+2]&255)<<16)|((buf[o+3]&255)<<24))
+      v >= MAX_LONG_SIGNED ? v-MAX_LONG_UNSIGNED : v
     end
 
     # converts bit-wise stored length from a header. "long" format is supported up to 32-bit

data/lib/rserve/rexp.rb

@@ -11,9 +11,6 @@ module Rserve
     def initialize(attr=nil)
       # Sorry for this, but I think is necessary to maintain sanity of attributes
       raise ArgumentError, "Attribute should be a REXP::List, #{attr.class} provided" unless attr.nil? or attr.is_a? REXP::List
-      
-
-      
       @attr=attr
     end
     # specifies how many items of a vector or list will be displayed in {@link #toDebugString}
@@ -22,111 +19,164 @@ module Rserve
     # check whether the <code>REXP</code> object is a character vector (string)
     # @return <code>true</code> if the receiver is a character vector, <code>false</code> otherwise
 
-    def string?;return false;end
+    def string?
+      false
+    end
 
       # # check whether the <code>REXP</code> object is a numeric vector
       # @return <code>true</code> if the receiver is a numeric vector, <code>false</code> otherwise
 
-    def numeric?;false;end
+    def numeric?
+      false
+    end
     # check whether the <code>REXP</code> object is an integer vector
     # @return <code>true</code> if the receiver is an integer vector, <code>false</code> otherwise
-    def integer?;false;end
+    def integer?
+      false
+    end
     # check whether the <code>REXP</code> object is NULL
     # @return <code>true</code> if the receiver is NULL, <code>false</code> otherwise
-    def null?;false;end
+    def null?
+      false
+    end
     # check whether the <code>REXP</code> object is a factor
     # @return <code>true</code> if the receiver is a factor, <code>false</code> otherwise
-    def factor?;false;end
+    def factor?
+      false
+    end
     # check whether the <code>REXP</code> object is a list (either generic vector or a pairlist - i.e. {@link #asList()} will succeed)
     # @return <code>true</code> if the receiver is a generic vector or a pair-list, <code>false</code> otherwise
-    def list?;false;end
+    def list?
+      false
+    end
     # check whether the <code>REXP</code> object is a pair-list
     # @return <code>true</code> if the receiver is a pair-list, <code>false</code> otherwise
-    def pair_list?;false;end
+    def pair_list?
+      false
+    end
     # check whether the <code>REXP</code> object is a logical vector
     # @return <code>true</code> if the receiver is a logical vector, <code>false</code> otherwise */
-    def logical?;false;end
+    def logical?
+      false
+    end
     #  check whether the <code>REXP</code> object is an environment
     # @return <code>true</code> if the receiver is an environment, <code>false</code> otherwise
-    def environment?;false;end
+    def environment?
+      false
+    end
     # check whether the <code>REXP</code> object is a language object
     # @return <code>true</code> if the receiver is a language object, <code>false</code> otherwise
-    def language?;false;end
+    def language?
+      false
+    end
     # check whether the <code>REXP</code> object is an expression vector
     # @return <code>true</code> if the receiver is an expression vector, <code>false</code> otherwise
-    def expression?;false;end
+    def expression?
+      false
+    end
     # check whether the <code>REXP</code> object is a symbol
     # @return <code>true</code> if the receiver is a symbol, <code>false</code> otherwise
-    def symbol?;false;end
+    def symbol?
+      false
+    end
     # check whether the <code>REXP</code> object is a vector
     # @return <code>true</code> if the receiver is a vector, <code>false</code> otherwise
-    def vector?;false;end
+    def vector?
+      false
+    end
     # check whether the <code>REXP</code> object is a raw vector
     # @return <code>true</code> if the receiver is a raw vector, <code>false</code> otherwise
-    def raw?;false;end
+    def raw?
+      false
+    end
     # check whether the <code>REXP</code> object is a complex vector
     # @return <code>true</code> if the receiver is a complex vector, <code>false</code> otherwise
-    def complex?;false;end
+    def complex?
+      false
+    end
     # check whether the <code>REXP</code> object is a recursive obejct
     # @return <code>true</code> if the receiver is a recursive object, <code>false</code> otherwise
-    def recursive?;false;end
+    def recursive?
+      false
+    end
     # check whether the <code>REXP</code> object is a reference to an R object
     # @return <code>true</code> if the receiver is a reference, <code>false</code> otherwise
-    def reference?;false;end
+    def reference?
+      false
+    end
     
     # :section: basic accessor methods
     # returns the contents as an array of Strings (if supported by the represented object)
-    def as_strings;raise MismatchException, "String";end
+    def as_strings
+      raise MismatchException, "String"
+    end
     # returns the contents as an array of integers (if supported by the represented object)
     
-    def as_integers; raise MismatchException, "int";end;
+    def as_integers
+      raise MismatchException, "int"
+    end
+
     # returns the contents as an array of doubles (if supported by the represented object)
-    def as_doubles; raise MismatchException,"double";end;
-    
+    def as_doubles
+       raise MismatchException,"double"
+    end
+
     # On Ruby, Float are stored in double precision
     def as_floats
       as_doubles
     end
     
     # returns the contents as an array of bytes (if supported by the represented object)
-    def as_bytes; raise MismatchException , "byte";end;
+    def as_bytes
+      raise MismatchException , "byte"
+    end
     # returns the contents as a (named) list (if supported by the represented object)
-    def as_list; raise MismatchException,"list";end;
+    def as_list
+      raise MismatchException,"list"
+    end
     # returns the contents as a factor (if supported by the represented object)
-    def as_factor; raise MismatchException,"factor";end;
+    def as_factor
+      raise MismatchException,"factor"
+    end
     
     # returns the length of a vector object. Note that we use R semantics here, i.e. a matrix will have a length of <i>m * n</i> since it is represented by a single vector (see {@link #dim} for retrieving matrix and multidimentional-array dimensions).
     # * @return length (number of elements) in a vector object
     # * @throws MismatchException if this is not a vector object
-    def length()
-    raise MismatchException, "vector";
+    def length
+      raise MismatchException, "vector"
     end
     
     # returns a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
     # *  @return a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
     # * @throws MismatchException if this is not a vector object
     def na?
-    raise MismatchException, "vector"
+      raise MismatchException, "vector"
     end
     
     # :section: convenience accessor methods
     # convenience method corresponding to <code>as_integer()[0]</code>
     # @return first entry returned by {@link #as_integer}
     def as_integer
-    as_integers[0]
+      as_integers[0]
+    end
+    def to_i
+      as_integers[0]
     end
     # convenience method corresponding to <code>asDoubles()[0]</code>
     # @return first entry returned by {@link #asDoubles}
     def as_double
-    as_doubles[0]
+      as_doubles[0]
     end
     def as_float
       as_double
     end
+    def to_f
+      as_double
+    end
     # convenience method corresponding to <code>asStrings()[0]</code>
     # @return first entry returned by {@link #asStrings}
     def as_string
-    as_strings[0]
+      as_strings[0]
     end
     # // methods common to all REXPs
     
@@ -135,15 +185,14 @@ module Rserve
     # * @return attribute value or <code>null</code> if the attribute does not exist
     
     def get_attribute(name)
-    nil if @attr.nil? or !@attr.list?
-    @attr.as_list[name]
+      has_attribute?(name)  ? @attr.as_list[name] : nil
     end
     
     # checks whether this obejct has a given attribute
     # * @param name attribute name
     # * @return <code>true</code> if the attribute exists, <code>false</code> otherwise
     def has_attribute? (name)
-    return (!@attr.nil? and @attr.list? and !@attr.as_list[name].nil?);
+      !@attr.nil? and @attr.list? and !@attr.as_list[name].nil?
     end
     
     
@@ -165,14 +214,14 @@ module Rserve
     # @return <code>true</code> if this object is of the class <code>klass</code>, <code>false</code> otherwise
     def inherits?(klass)
       return false if (!has_attribute? "class")
-    begin
-    c = get_attribute("class").as_strings;
-    if (!c.nil?)
-      return c.any? {|v| v.equals klass}
-    end
-    rescue MismatchException
-    end
-    return false;
+      begin
+        c = get_attribute("class").as_strings;
+        if (!c.nil?)
+          return c.any? {|v| v.equals klass}
+        end
+      rescue MismatchException
+      end
+      false
     end
     
 
@@ -180,7 +229,7 @@ module Rserve
     # returns representation that it useful for debugging (e.g. it includes attributes and may include vector values -- see {@link #maxDebugItems})
     # @return extended description of the obejct -- it may include vector values
     def to_debug_string
-    (!@attr.nil?) ? (("<"+@attr.to_debug_string()+">")+to_s()) : to_s
+      (!@attr.nil?) ? (("<"+@attr.to_debug_string()+">")+to_s()) : to_s
     end
     
     
@@ -196,16 +245,54 @@ module Rserve
       raise MismatchException, "matrix (dim attribute missing)" if dim.nil?
       ds = dim.as_integers
       raise MismatchException, "matrix (wrong dimensionality)"     if (ds.length!=2)
-      m,n = ds[0], ds[1]
+      as_nested_array
+      
+      #m,n = ds[0], ds[1]
       # R stores matrices as matrix(c(1,2,3,4),2,2) = col1:(1,2), col2:(3,4)
       # we need to copy everything, since we create 2d array from 1d array
-      r=m.times.map {|i| n.times.map {|j| ct[j*n+i]}}
+      #r=m.times.map {|i| n.times.map {|j| ct[j*n+i]}}
     end
     # Returns a standard library's matrix
     def as_matrix
       require 'matrix'
       Matrix.rows(as_double_matrix)
     end
+    # Returns the content of the REXP as a serie of nested arrays of X dimensions
+    def as_nested_array
+      ct=as_doubles
+      dim = get_attribute "dim"
+      raise MismatchException, "array (dim attribute missing" if dim.nil?
+      ds = dim.as_integers.reverse
+      
+      split_array(ct,ds)
+    end
+    
+    def split_array(ar, dims)
+#      puts "#{ar} - #{dims}"
+      if dims.size==1
+        raise "Improper size ar:#{ar} , dims=#{dims[0]}" if ar.size!=dims[0]
+        return ar 
+      elsif dims.size==2
+        # should rearrange values as R do
+        out=[]
+        ar.each_with_index {|v,i| 
+          r=(i/dims[1]).to_i;
+          c=i%dims[1];
+#          p "#{r} : #{c}";
+          out[c*dims[0]+r]=v
+        }
+        raise "out size should equal to ar size" if ar.size!=out.size
+        ar=out
+      end
+      dims_c=dims.dup
+      current_dim=dims_c.shift
+      current_size=ar.size/current_dim
+      #puts "dims: #{dims_c} cs:#{current_size}, cd:#{current_dim}"
+      parts=current_dim.times.map do |i|
+        split_array(ar[i*current_size, current_size], dims_c)
+      end
+      parts
+    end
     
     # :section: tools
     
@@ -213,25 +300,54 @@ module Rserve
     # *  @param l a (named) list of vectors ({@link REXPVector} subclasses), each element corresponds to a column and all elements must have the same length
     # *  @return a data frame object
     #  *  @throws MismatchException if the list is empty or any of the elements is not a vector
-    def create_data_frame(l)
-    raise(MismatchException, "data frame (must have dim>0)") if l.nil? or l.size<1
-    raise MismatchException, "data frame (contents must be vectors)" if (!(l[0].is_a? REXP::Vector))
-    fe = l[0]
-    return REXP::GenericVector.new(l,
-    REXP::List.new(
-    RList.new(
-    [
-    REXP::String.new("data.frame"),
-    REXP::String.new(l.keys()),
-    REXP::Integer.new([REXP::Integer.NA, -fe.length()])
-    ],
-    ["class", "names", "row.names" ])
-    )
-    )
+    def self.create_data_frame(l)
+      raise(MismatchException, "data frame (must have dim>0)") if l.nil? or l.size<1
+      raise MismatchException, "data frame (contents must be vectors)" if (!(l[0].is_a? REXP::Vector))
+      fe = l[0]
+      return REXP::GenericVector.new(l,
+      REXP::List.new(
+      Rlist.new(
+      [
+      REXP::String.new("data.frame"),
+      REXP::String.new(l.keys()),
+      REXP::Integer.new([REXP::Integer::NA, -fe.length()])
+      ],
+      ["class", "names", "row.names" ])
+      )
+      )
     end
     # Retrieves the best Ruby representation of data
+    #
+    # If R object has attributes, the Ruby object is extended with Rserve::WithAttributes.
+    # If R object is names, the Ruby object is extended with Rserve::WithNames and
+    # their elements can be accessed with [] using numbers and literals.
+    # 
     def to_ruby
-    raise "You should implement this!"
+      #pp self
+      v=to_ruby_internal
+      #p v
+      if !v.nil? and !v.is_a? Fixnum and !v.is_a? TrueClass and !v.is_a? FalseClass
+        v.extend Rserve::WithAttributes
+        v.attributes=attr.to_ruby unless attr.nil?
+        if !v.attributes.nil? and v.attributes.has_name? 'names'
+          v.attributes['names']=[v.attributes['names']] unless v.attributes['names'].is_a? Array or v.attributes['names'].nil?
+          
+          v.extend Rserve::WithNames
+          
+          v.names=v.attributes['names']
+        end
+      end
+      
+      # Hack: change attribute row.names according to spec 
+      if !attr.nil? and attr.as_list.has_name? 'class' and attr.as_list['class'].as_string=='data.frame' and attr.as_list['row.names'].as_integers[0]==REXP::Integer::NA
+        v.attributes['row.names']=(1..(-attr.as_list['row.names'].as_integers[1])).to_a
+      end
+      
+      
+      v
+    end
+    def to_ruby_internal
+      raise "You should implement to_ruby_internal for #{self.class}"
     end
   end
 end

data/lib/rserve/rexp/double.rb

@@ -49,9 +49,13 @@ module Rserve
       t=super
       t << "{"  << @payload.map(&:to_s).join(",") << "}"
     end
-    def to_ruby
-      if !attr.nil? and !attr.as_list['dim'].nil? and attr.as_list['dim'].to_ruby.size==2
-        as_matrix
+    def to_ruby_internal
+      if dim 
+        if dim.size==2
+          as_matrix
+        else
+          as_nested_array
+        end
       else
         super
       end

data/lib/rserve/rexp/environment.rb

@@ -32,9 +32,6 @@ module Rserve
       def parent(resolve=true)
         @eng.get_parent_environment(self,resolve)
       end
-      def to_ruby
-        raise "No idea how to transform #{self.class}"
-      end
     end
   end
 end

data/lib/rserve/rexp/factor.rb

@@ -18,6 +18,9 @@ module Rserve
       def to_s
         super+"[#{levels.length}]"
       end
+      def to_ruby_internal
+        as_strings
+      end
     end
   end
 end

data/lib/rserve/rexp/genericvector.rb

@@ -23,7 +23,7 @@ module Rserve
       def as_list
         @payload
       end
-      def to_ruby
+      def to_ruby_internal
         @payload.to_ruby
       end
     end

data/lib/rserve/rexp/integer.rb

@@ -44,6 +44,18 @@ module Rserve
       t=super
       t << "{"  << @payload.map(&:to_s).join(",") << "}"
     end
+    def to_ruby_internal
+      if dim
+        if dim.size==2
+          as_matrix
+        else
+          as_nested_array
+        end
+      else
+        super
+      end
+    end
+    
   end
 end
 end

data/lib/rserve/rexp/list.rb

@@ -33,7 +33,7 @@ module Rserve
         end
         t+inner
       end
-      def to_ruby
+      def to_ruby_internal
         as_list.to_ruby
       end
     end

data/lib/rserve/rexp/logical.rb

@@ -60,7 +60,7 @@ module Rserve
         @payload.map {|v| v==FALSE}
       end
       
-      def to_ruby
+      def to_ruby_internal
         if @payload.nil? or @payload.size==0
           nil
         elsif @payload.size==1

data/lib/rserve/rexp/unknown.rb

@@ -9,6 +9,9 @@ module Rserve
       def to_s
         super()+"[#{@type}]"
       end
+      def to_ruby_internal
+        @type.to_s
+      end
     end
   end
 end

data/lib/rserve/rexp/vector.rb

@@ -9,10 +9,10 @@ module Rserve
 
       # returns the length of the vector (i.e. the number of elements)
       # @return length of the vector
-      def length;
-      end;
-      def vector?;
-        true;
+      def length
+      end
+      def vector?
+        true
       end
       # returns a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values
       # @return a boolean vector of the same length as this vector with <code>true</code> for NA values and <code>false</code> for any other values */
@@ -24,7 +24,7 @@ module Rserve
       def to_a
         @payload.map {|v| na?(v) ? nil : v }
       end
-      def to_ruby
+      def to_ruby_internal
         if @payload.nil? or @payload.size==0
           nil
         elsif @payload.size==1

data/lib/rserve/rfactor.rb

@@ -49,7 +49,7 @@ module Rserve
       @ids
     end
     def as_strings
-      @ids.map {|v| @levels[v-index_base]}
+      @ids.map {|v| v==REXP::Integer::NA ? nil : @levels[v-index_base]}
     end
     def index_at(i)
       @ids[i]

data/lib/rserve/withattributes.rb

@@ -1,5 +1,8 @@
 module Rserve
   module WithAttributes
     attr_accessor :attributes
+    def has_attribute?(v)
+      !@attributes.nil? and !attributes[v].nil?
+    end
   end
 end

data/lib/rserve/withnames.rb

@@ -3,7 +3,7 @@ module Rserve
   module WithNames
     attr_reader :names
     def names=(v)
-      raise ArgumentError, "#size should be equal to object size" if !v.nil? and v.size!=self.size
+      raise ArgumentError, "#{self}: names size #{v.size} should be equal to object size #{self.size}" if !v.nil? and v.size!=self.size
       raise ArgumentError, "element must be String or nil" unless v.nil? or v.all? {|v1| v1.nil? or v1.is_a? String}
       @names=v
     end
@@ -13,8 +13,34 @@ module Rserve
       @names.push(name)
       super(v)
     end
+    def pretty_print(q)
+      q.group(1,'[|WN|',']') {
+        q.seplist(self,nil,:each_with_index) {|v,i|
+         if (@names.nil? or @names[i].nil?) 
+           q.pp v
+          else
+            q.group {
+            q.pp @names[i]
+            q.text '='
+            q.group(1) { q.pp v } 
+            }
+          end
+        }
+      }
+    end
+    def to_s
+      out=[]
+      self.each_with_index { |v,i| 
+      if !@names.nil? and !@names[i].nil?
+        out.push("#{@names[i]}=#{v}")
+      else
+        out.push("#{v}")
+      end
+      }
+      "[#{out.join(", ")}]"
+    end
     def inspect
-      "#<#{self.class}:#{self.object_id} #{super} names:#{@names.inspect}>"
+      "#<#{self.class}:#{self.object_id} #{to_s}>"
     end
     def clear
       @names=nil
@@ -53,6 +79,9 @@ module Rserve
       end
       sliced
     end
+    def has_name?(v)
+      named? and @names.include? v
+    end
     def named?
       !@names.nil?
     end
@@ -74,7 +103,7 @@ module Rserve
       if !@names.nil?
         pos=@names.index(key)
         if !pos.nil?
-          return @names[pos]=value
+          return self[pos]=value
         end
       end      
       push(value,key)      
@@ -89,6 +118,16 @@ module Rserve
         @names.insert(a,nil)
       end
     end
+    def []=(i,v)
+      case i
+        when Integer
+          super(i,v)
+        when String
+          put(i,v)
+        else
+          raise "Should be Integer or String"
+      end
+    end
     def [](v)
       case v
       when Integer

data/spec/rserve_rexp_spec.rb

@@ -19,6 +19,14 @@ describe Rserve::REXP do
       @m=@r.eval('matrix(c(1,2,3,4,5,6,7,8,9), 3,3)')
       @m.as_matrix.should==Matrix[[1,4,7],[2,5,8],[3,6,9]]
     end
+    it "method split_array returns a valid splitted array" do
+      @m.as_double_matrix.should==@m.as_nested_array
+      @r.void_eval("a=1:16; attr(a,'dim')<-c(2,2,2,2)")
+      a=@r.eval("a")
+      a.as_nested_array.should==[[[[1.0, 3.0], [2.0, 4.0]], [[5.0, 7.0], [6.0, 8.0]]],
+ [[[9.0, 11.0], [10.0, 12.0]], [[13.0, 15.0], [14.0, 16.0]]]]
+      
+    end
   end
   describe "common methods" do
     before do
@@ -46,7 +54,15 @@ describe Rserve::REXP do
     it "method get_attribute should return correct value for attribute" do
       @l.get_attribute('names').as_strings.should==['at']
     end
-
+    it "method create_data_frame should create a valid data frame" do
+      l=Rserve::Rlist.new([Rserve::REXP::Integer.new([1,2,3,4,5,6,7,8,9,10])],['a'])
+      @r.assign "b", Rserve::REXP.create_data_frame(l)
+      b=@r.eval("b")
+      b.attr.as_list['class'].as_string.should=='data.frame'
+      b.attr.as_list['row.names'].as_integers.should==[Rserve::REXP::Integer::NA, -10]
+      b.attr.as_list['names'].as_strings.should==['a']      
+      
+    end
   end
 
 end

data/spec/rserve_rexp_to_ruby_spec.rb

@@ -11,20 +11,49 @@ describe "Rserve::REXP#to_ruby" do
     it "should return an array of Fixnum and nils with vector with two or more elements" do
       @r.eval("c(1,2,3,NA)").to_ruby.should==[1,2,3,nil]
     end
+    
+    it "should return an array of Fixnum with an enumeration" do
+      @r.eval("1:10").to_ruby.should==[1,2,3,4,5,6,7,8,9,10]
+    end
+    it "should return an array of String with a factor" do
+      @r.eval("factor(c(NA,'a','b','b','c'))").to_ruby.should==[nil]+%w{a b b c}
+    end
+    it "should return an array of String and nils with a factor with NA" do
+      @r.eval("factor(c('a','a','b','b','c'))").to_ruby.should==%w{a a b b c}
+    end
+    
     it "should return a rational with vector with one element" do
       @r.eval("c(0.5)").to_ruby.should==1.quo(2)
     end
     it "should return an array of rationals with vector with more than one elements" do
       @r.eval("c(0.5,0.5,NA)").to_ruby.should==[1.quo(2), 1.quo(2),nil]
     end
+    it "should return an object with module WithAttributes included, when attributes are set" do
+      @r.void_eval("a<-c(1,2,3);attr(a,'names')<-c('a','b','c');")
+      a=@r.eval("a").to_ruby
+      a.attributes.names.should==['names']
+      a.attributes['names'].should==%w{a b c}
+    end
     it "should return a Ruby Matrix with R matrix" do
       @r.eval("matrix(c(1,2,3,4),2,2)").to_ruby.should==Matrix[[1,3],[2,4]]
     end
-    it "should return a nested array of Ruby Matrixes with vector with more than tree dimensions" 
+    it "should return a nested array of Ruby Matrixes with vector with more than tree dimensions"  do
+      @r.void_eval("a<-1:16; attr(a,'dim')<-c(2,2,2,2)")
+      @r.eval("a").to_ruby.should==[[[[1.0, 3.0], [2.0, 4.0]], [[5.0, 7.0], [6.0, 8.0]]],
+ [[[9.0, 11.0], [10.0, 12.0]], [[13.0, 15.0], [14.0, 16.0]]]]
+      
+    end
     it "should return a boolean with a logical with one element" do
       @r.eval("TRUE").to_ruby.should be_true
     end
-    
+    it "should return an array extended with Rserve::WithNames if vector is named" do
+      @r.void_eval("a<-c(1,2,3);names(a)<-c('a','b','c')")
+      v=@r.eval('a').to_ruby
+      v.names.should==['a','b','c']
+      v[0].should==1
+      v['a'].should==1
+      
+    end
     it "should return an array of booleans with a logical with two or more elements" do
       @r.eval("c(TRUE,FALSE,NA)").to_ruby.should==[true,false,nil]
     end
@@ -35,10 +64,20 @@ describe "Rserve::REXP#to_ruby" do
     it "should return an array of strings with a vector with two or more strings" do
       @r.eval("c('a','b',NA)").to_ruby.should==['a','b',nil]
     end
-    it "should return an array extended with Rserve::WithNames for a list" do
+    it "should return an array extended with Rserve::WithNames and Rserve::WithAttributes for a list" do
       expected=[1,2,3].extend Rserve::WithNames
       expected.names=%w{a b c}
-      @r.eval('list(a=1,b=2,c=3)').to_ruby.should==expected
+      list=@r.eval('list(a=1,b=2,c=3)').to_ruby
+      list.names.should==expected.names
+      list.attributes['names'].should==%w{a b c}
+    end
+    it "should return a data.frame as an array with Rserve::WithNames and Rserve::WithAttributes" do
+      df=@r.eval('data.frame(a=1:10)').to_ruby
+      df['a'].should==[1,2,3,4,5,6,7,8,9,10]
+      df.attributes['names'].should==['a']
+      df.attributes['row.names'].should==[1,2,3,4,5,6,7,8,9,10]
+      df.attributes['class'].should=='data.frame'
+      
     end
   end
 end

data/spec/rserve_rexpfactory_spec.rb

@@ -46,6 +46,11 @@ describe Rserve::Protocol::REXPFactory do
       v.should be_close(a[i],1e-10)
     }
   end
+  it "should process integer" do
+    la=@r.eval("-10:10")
+    la.should be_instance_of(Rserve::REXP::Integer)
+    la.as_integers.should==(-10..10).to_a
+  end
   it "should process double vector with NA" do
     la=@r.eval("c(1,NA)")
     la.should be_instance_of(Rserve::REXP::Double)
@@ -111,7 +116,12 @@ describe Rserve::Protocol::REXPFactory do
     la.should be_true
     la.attr.as_list['names'].to_ruby.should==%w{a b}
     la.attr.as_list['class'].to_ruby.should=="data.frame"
-    #la.attr.as_list['row.names'].to_ruby.should==[1,2,3,4,5,6,7,8,9,10]
+    la.attr.as_list['row.names'].to_ruby.should==[nil,-10]
+  end
+  it "should process a nested array" do
+    @r.void_eval("c=1:8; attr(c,'dim')<-c(2,2,2)")
+    la=@r.eval("c")
+    la.attr.as_list['dim'].to_ruby.should==[2,2,2]
   end
 
   it "should retrieve correct lenght for string" do

data/spec/rserve_withnames_spec.rb

@@ -36,6 +36,17 @@ describe Rserve::WithNames do
       @a['a'].should==1
       @a['b'].should==2
     end
+    it "should set values with numeric indexes" do
+      @a[0]=10
+      @a.should==[10,2,3,4]
+    end
+    it "should set values with string indexes" do
+      @a['a']=10
+      @a.should==[10,2,3,4]
+      @a.put('b',20)
+      @a.should==[10,20,3,4]
+    end
+
     it "should push with or without name" do
       @a.push(5)
       @a.names.should==['a','b','c',nil,nil]

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 8
-  version: 0.1.8
+  - 9
+  version: 0.1.9
 platform: ruby
 authors: 
 - Claudio Bustos
@@ -35,7 +35,7 @@ cert_chain:
   rpP0jjs0
   -----END CERTIFICATE-----
 
-date: 2010-06-01 00:00:00 -04:00
+date: 2010-06-04 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -77,18 +77,22 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- Examples.txt
 - History.txt
+- Introduction.txt
 - Manifest.txt
 - README.txt
 files: 
-- Examples.txt
+- .autotest
 - History.txt
+- Introduction.txt
 - Manifest.txt
 - README.txt
 - Rakefile
+- data/gettysburg.txt
+- examples/gettysburg.rb
 - examples/hello_world.rb
 - examples/lowless.rb
+- examples/regression.rb
 - lib/rserve.rb
 - lib/rserve/connection.rb
 - lib/rserve/engine.rb