rserve-client 0.1.5 → 0.1.6

data/lib/rserve/rexp/environment.rb

@@ -0,0 +1,40 @@
+module Rserve
+  class REXP
+    # REXPEnvironment represents an environment in R. Very much like {@link org.rosuda.REngine.REXPReference} this is a proxy object to the actual object on the R side. It provides methods for accessing the content of the environment. The actual implementation may vary by the back-end used and not all engines support environments. Check {@link org.rosuda.REngine.REngine.supportsEnvironments()} for the given engine. Environments are specific for a given engine, they cannot be passed across engines
+    class Environment < REXP
+      attr_reader :eng
+      attr_reader :handle
+      # create a new environemnt reference - this constructor should never be used directly, use {@link REngine.newEnvironment()} instead.
+      # * @param eng engine responsible for this environment
+      # * @param handle handle used by the engine to identify this environment
+      def initialize(e,h)
+        super();
+        @eng = e;
+        @handle = h;
+      end
+      def environment?
+        true
+      end
+
+      # get a value from this environment
+      # * @param name name of the value
+      # * @param resolve if <code>false</code> returns a reference to the object, if <code>false</code> the reference is resolved
+      # * @return value corresponding to the symbol name or possibly <code>null</code> if the value is unbound (the latter is currently engine-specific)
+      def get(name, resolve=true)
+        @eng.get(name,self,resolve)
+      end
+      # assigns a value to a given symbol name
+      #  @param name symbol name
+      #  @param value value */
+      def assign(name, value)
+        @eng.assign(name, value, self)
+      end
+      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/expressionvector.rb

@@ -0,0 +1,9 @@
+module Rserve
+  class REXP
+    class ExpressionVector < REXP::GenericVector
+      def expression?
+        true
+      end
+    end
+  end
+end

data/lib/rserve/rexp/genericvector.rb

@@ -2,14 +2,13 @@ module Rserve
   class REXP
     class GenericVector < REXP::Vector
       attr_reader :payload
-      def initialize(list,attr=nil)
+      def initialize(list, attr=nil)
         super(attr)
         @payload=list.nil? ? Rlist.new() : list
-        
         if (payload.named?)
           @attr = REXP::List.new(
           Rlist.new([REXP::String.new(payload.keys())],
-						  ["names"]));
+          ["names"]));
         end
       end
       def length
@@ -24,6 +23,9 @@ module Rserve
       def as_list
         @payload
       end
+      def to_ruby
+        @payload.to_ruby
+      end
     end
   end
 end

data/lib/rserve/rexp/integer.rb

@@ -6,44 +6,44 @@ module Rserve
       NA = -2147483648;
       def initialize(data, attrs=nil)
         @payload=case data
-          when Integer
-            [data]
-          when Numeric
-            [data.to_i]
-          when Array
-            data
-          else
-            raise ArgumentError, "Should be Numeric or Array"
-          end
-        super(attrs)
-      end
-      def length
-        payload.length
-      end
-      def integer?
-        true
-      end
-      def numeric?
-        true
-      end
-      def as_integers
-        @payload
-      end
-      def as_doubles
-        @payload.map(&:to_f)
-      end
-      def as_strings
-        @payload.map(&:to_s)
-      end
-      
-      def na?(value=nil)
-        return value == NA unless value.nil?
-        @payload.map {|v| v==NA}
-      end
-      def to_debug_string
-        t=super
-        t << "{"  << @payload.map(&:to_s).join(",") << "}"
-      end
+      when Integer
+        [data]
+      when Numeric
+        [data.to_i]
+      when Array
+        data
+      else
+        raise ArgumentError, "Should be Numeric or Array"
+      end
+      super(attrs)
+    end
+    def length
+      payload.length
+    end
+    def integer?
+      true
+    end
+    def numeric?
+      true
+    end
+    def as_integers
+      @payload
+    end
+    def as_doubles
+      @payload.map(&:to_f)
+    end
+    def as_strings
+      @payload.map(&:to_s)
+    end
+
+    def na?(value=nil)
+      return value == NA unless value.nil?
+      @payload.map {|v| v==NA}
+    end
+    def to_debug_string
+      t=super
+      t << "{"  << @payload.map(&:to_s).join(",") << "}"
     end
   end
 end
+end

data/lib/rserve/rexp/language.rb

@@ -1,9 +1,9 @@
 module Rserve
   class REXP
-    class Language < REXP::List 
+    class Language < REXP::List
       def initialize(list, attr=nil)
         super(list,attr)
-        
+
       end
       def language?
         true

data/lib/rserve/rexp/list.rb

@@ -33,6 +33,9 @@ module Rserve
         end
         t+inner
       end
+      def to_ruby
+        as_list.to_ruby
+      end
     end
   end
 end

data/lib/rserve/rexp/logical.rb

@@ -17,7 +17,7 @@ module Rserve
       def initialize(l,attr=nil)
         super(attr)
         if l.is_a? Array
-          @payload= l 
+          @payload= l
         else
           @payload = [ l==NA ? NA : (l==1 ? TRUE : FALSE) ]
         end
@@ -31,14 +31,27 @@ module Rserve
       def as_bytes
         @payload
       end
+
+      # Retrieves values as Ruby array of true and false values
+      # NA will be replaced with nils
+      def to_a
+        @payload.map {|v|
+          case v
+          when NA then nil
+          when TRUE then true
+          when FALSE then false
+          end
+        }
+      end
+
       def as_integers
-        @payload.map {|v| v==NA ? REXP::Integer::NA : ( v == FALSE ? 0 : 1 )} 
+        @payload.map {|v| v==NA ? REXP::Integer::NA : ( v == FALSE ? 0 : 1 )}
       end
       def as_doubles
-        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? 0.0 : 1.0 )} 
+        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? 0.0 : 1.0 )}
       end
       def as_strings
-        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? "FALSE" : "TRUE" )} 
+        @payload.map {|v| v==NA ? REXP::Double::NA : ( v == FALSE ? "FALSE" : "TRUE" )}
       end
       def true?
         @payload.map {|v| v==TRUE}

data/lib/rserve/rexp/null.rb

@@ -1,17 +1,23 @@
 module Rserve
   class REXP
-# represents a NULL object in R.
-# Note: there is a slight asymmetry - in R NULL is represented by a zero-length pairlist. For this reason <code>REXPNull</code> returns <code>true</code> for {@link #isList()} and {@link #asList()} will return an empty list. Nonetheless <code>REXPList</code> of the length 0 will NOT return <code>true</code> in {@link #isNull()} (currently), becasue it is considered a different object in Java. These nuances are still subject to change, because it's not clear how it should be treated. At any rate use <code>REXPNull</code> instead of empty <code>REXPList</code> if NULL is the intended value.
- class Null < REXP 
-   def null?
-     true
-   end
-   def list?
-     true
-   end
-   def as_list
-     Rlist.new
-   end
- end
-end
+    # represents a NULL object in R.
+    # Note: there is a slight asymmetry - in R NULL is represented by a zero-length pairlist. For this reason <code>REXPNull</code> returns <code>true</code> for {@link #isList()} and {@link #asList()} will return an empty list. Nonetheless <code>REXPList</code> of the length 0 will NOT return <code>true</code> in {@link #isNull()} (currently), becasue it is considered a different object in Java. These nuances are still subject to change, because it's not clear how it should be treated. At any rate use <code>REXPNull</code> instead of empty <code>REXPList</code> if NULL is the intended value.
+    class Null < REXP
+      def null?
+        true
+      end
+      def ==(v)
+        v.is_a? self.class
+      end
+      def list?
+        true
+      end
+      def as_list
+        Rlist.new
+      end
+      def to_ruby
+        nil
+      end
+    end
+  end
 end

data/lib/rserve/rexp/raw.rb

@@ -0,0 +1,19 @@
+module Rserve
+  class REXP
+    class Raw < REXP::Vector
+      def initialize(l,attr=nil)
+        super(attr);
+        @payload=(l.nil?) ? Array.new() : l;
+      end
+      def length
+        @payload.length
+      end
+      def raw?
+        true
+      end
+      def as_bytes
+        @payload
+      end
+    end
+  end
+end

data/lib/rserve/rexp/reference.rb

@@ -0,0 +1,42 @@
+require 'forwardable'
+module Rserve
+  class REXP
+    class Reference < REXP
+      extend Forwardable
+      attr_reader :eng
+      attr_reader :handle
+      attr_reader :resolved_value
+
+      def initialize(e,h)
+        super()
+        @eng=e
+        @handle=h
+        @resolved_value=nil
+      end
+
+      # check type methods
+      def_delegators :@resolved_value, :string?, :numeric?, :integer?, :null?, :factor?, :list?, :logical?, :environment? , :language?, :symbol?, :vector?, :raw?, :complex?, :recursive?
+      # convertion methods
+      def_delegators :@resolved_value, :as_strings, :as_integers, :as_floats, :as_list, :as_factor
+      # other methods
+      def_delegators :@resolved_value, :attr, :length
+
+      def reference?
+        true
+      end
+      def resolve
+        @resolved_value||= @eng.resolve_reference(self)
+      end
+      def invalidate
+        @resolved_value=nil
+      end
+      def finalize
+        begin
+          @eng.finalize_reference(self)
+        ensure
+          super.finalize()
+        end
+      end
+    end
+  end
+end

data/lib/rserve/rexp/s4.rb

@@ -0,0 +1,10 @@
+module Rserve
+  class REXP
+    # S4 REXP is a completely vanilla REXP
+    class S4 < REXP
+      def initialize(attr=nil)
+        super(attr)
+      end
+    end
+  end
+end

data/lib/rserve/rexp/string.rb

@@ -2,13 +2,14 @@ module Rserve
   class REXP
     class String < REXP::Vector
       attr_reader :payload
+      NA="NA"
       def initialize(data, attrs=nil)
         @payload=case data
         when Array
           data.map {|v| v.to_s}
-          else
-            [data.to_s]
-          end
+        else
+          [data.to_s]
+        end
         super(attrs)
       end
       def length
@@ -28,6 +29,7 @@ module Rserve
         t=super
         t << "{"  << @payload.map(&:to_s).join(",") << "}"
       end
+      
     end
   end
 end

data/lib/rserve/rexp/symbol.rb

@@ -21,6 +21,9 @@ module Rserve
       def to_debug_string
         super+"["+name+"]"
       end
+      def to_ruby
+        @name
+      end
     end
   end
 end

data/lib/rserve/rexp/vector.rb

@@ -1,23 +1,38 @@
 module Rserve
   class REXP
     class Vector < REXP
+      attr_reader :payload
+      def ==(o)
+        #p "Comparing #{self.inspect} with #{o.inspect} gives #{self.payload==o.payload and self.attr==o.attr}"
+        self.class==o.class and self.payload==o.payload and self.attr==o.attr
+      end
+
       # returns the length of the vector (i.e. the number of elements)
-      # @return length of the vector 
-	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 */
-        def na?
-        end
-        def to_s
-          super+"[#{length}]"
-        end
-        def to_debug_string
-          super+"[#{length}]"
+      # @return length of the vector
+      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 */
+      def na?
+      end
+
+      # Retrieves values as Ruby array
+      # NA will be replaced with nils
+      def to_a
+        @payload.map {|v| na?(v) ? nil : v }
+      end
+      def to_ruby
+        if @payload.nil? or @payload.size==0
+          nil
+        elsif @payload.size==1
+          @payload[0]
+        else
+          @payload.map {|v| na?(v) ? nil : v}
         end
+      end
     end
   end
 end

data/lib/rserve/rexp/wrapper.rb

@@ -0,0 +1,58 @@
+module Rserve
+  class REXP
+    #
+    #  Utility module to wrap an Ruby Object into a REXP object.
+    #
+    # This facilitates wrapping native ruby objects and arrays
+    # into REXP objects that can be pushed to R
+    #
+    # @author Romain Francois <francoisromain@free.fr>
+    #
+    module Wrapper
+      def self.wrap(o)
+        return o if o.is_a? REXP
+        case o
+        when TrueClass
+          REXP::Logical.new(1)
+        when FalseClass
+          REXP::Logical.new(0)
+        when NilClass
+          REXP::Null.new()
+        when ::String
+          REXP::String.new(o)
+        when Integer
+          REXP::Integer.new(o)
+        when Fixnum
+          REXP::Integer.new(o)
+        when Float
+          REXP::Double.new(o)
+        when Array
+          find_type_of_array(o)
+        else
+          puts "Clase:#{o.class}"
+          nil
+        end
+      end
+      def self.find_type_of_array(o)
+        if o.all? {|v| v.nil?}
+          REXP::Integer.new([REXP::Integer::NA]*o.size)
+        elsif o.all? {|v| v.is_a? Integer or v.is_a? Fixnum or v.nil?}
+          REXP::Integer.new(o.map {|v| v.nil? ? REXP::Integer::NA : v})
+        elsif o.all? {|v| v.is_a? Numeric or v.nil?}
+          REXP::Double.new(o.map {|v| v.nil? ? REXP::Double::NA : v.to_f})
+        elsif o.all? {|v| v.is_a? ::String or v.nil?}
+          REXP::String.new(o.map {|v| v.nil? ? REXP::String::NA : v})
+        elsif o.all? {|v| v.is_a? TrueClass or v.is_a? FalseClass or v.nil?}
+          REXP::Logical.new(o.map{|v| v.nil? ? REXP::Logical::NA : (v ? 1 : 0)})
+          # mixed values. We must return a LIST!
+        else
+          REXP::GenericVector.new(
+          Rlist.new(
+          o.map{|v| wrap(v)}
+          )
+          )
+        end
+      end
+    end
+  end
+end