rinruby 1.0.1 → 1.1.0

data/lib/rinruby.rb

@@ -59,7 +59,7 @@
 
 class RinRuby
 
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 
   require 'socket'
 
@@ -82,7 +82,7 @@ class RinRuby
 #
 #* echo: By setting the echo to false, output from R is suppressed, although warnings are still printed. This option can be changed later by using the echo method. The default is true.
 #* interactive: When interactive is false, R is run in non-interactive mode, resulting in plots without an explicit device being written to Rplots.pdf. Otherwise (i.e., interactive is true), plots are shown on the screen. The default is true.
-#* executable: The path of the R executable (which is "R" in Linux and Mac OSX, or "Rterm.exe" in Windows) can be set with the executable argument. The default is nil which makes RinRuby use the registry keys to find the path (on Windows) or use the path defined by $PATH (on Linux and Mac OS X).
+#* executable: The path of the R executable (which is "R" in Linux and Mac OS X, or "Rterm.exe" in Windows) can be set with the executable argument. The default is nil which makes RinRuby use the registry keys to find the path (on Windows) or use the path defined by $PATH (on Linux and Mac OS X).
 #* port_number: This is the smallest port number on the local host that could be used to pass data between Ruby and R. The actual port number used depends on port_width.
 #* port_width: RinRuby will randomly select a uniform number between port_number and port_number + port_width - 1 (inclusive) to pass data between Ruby and R. If the randomly selected port is not available, RinRuby will continue selecting random ports until it finds one that is available. By setting port_width to 1, RinRuby will wait until port_number is available. The default port_width is 1000.
 #
@@ -103,6 +103,7 @@ class RinRuby
       end
     end
     @echo_enabled = echo
+    @echo_stderr = false
     @interactive = interactive
     @platform = case RUBY_PLATFORM
       when /mswin/: 'windows'
@@ -137,17 +138,19 @@ class RinRuby
     @reader = @engine
     @writer = @engine
     @writer.puts <<-EOF
-      keep.trying <- TRUE
-      while ( keep.trying ) {
+      #{RinRuby_KeepTrying_Variable} <- TRUE
+      while ( #{RinRuby_KeepTrying_Variable} ) {
         #{RinRuby_Socket} <- try(suppressWarnings(socketConnection("127.0.0.1",#{@port_number},blocking=TRUE,open="rb")),TRUE)
         if ( inherits(#{RinRuby_Socket},"try-error") ) {
           Sys.sleep(0.1)
         } else {
-          keep.trying <- FALSE
+          #{RinRuby_KeepTrying_Variable} <- FALSE
         }
       }
+      rm(#{RinRuby_KeepTrying_Variable})
     EOF
     @socket = @server_socket.accept
+    echo(nil,true) if @platform =~ /.*-java/      # Redirect error messages on the Java platform
   end
 
 #The quit method will properly close the bridge between Ruby and R, freeing up system resources. This method does not need to be run when a Ruby script ends.
@@ -175,6 +178,7 @@ class RinRuby
 #         Min. 1st Qu.        Median      Mean 3rd Qu.         Max.
 #      -1.88900 -0.84930 -0.45220 -0.49290 -0.06069          0.78160
 #      [1] 0.7327981
+#
 #This example used a string substitution to make the argument to first eval method equivalent to x <- rnorm(10). This example used three invocations of the eval method, but a single invoke is possible using a here document:
 #
 #      >> R.eval <<EOF
@@ -195,11 +199,12 @@ class RinRuby
 
   def eval(string, echo_override=nil)
     echo_enabled = ( echo_override != nil ) ? echo_override : @echo_enabled
-    begin
+    if complete?(string)
       @writer.puts string
+      @writer.puts "warning('#{RinRuby_Stderr_Flag}',immediate.=TRUE)" if @echo_stderr
       @writer.puts "print('#{RinRuby_Eval_Flag}')"
-    rescue
-      return false
+    else
+      raise "Parse error"
     end
     Signal.trap('INT') do
       @writer.print ''
@@ -208,7 +213,10 @@ class RinRuby
       end
       return true
     end
+    found_eval_flag = false
+    found_stderr_flag = false
     while true
+      echo_eligible = true
       begin
         line = @reader.gets
       rescue
@@ -220,9 +228,17 @@ class RinRuby
       while line.chomp!
       end
       line = line[8..-1] if line[0] == 27     # Delete escape sequence
-      break if line == "[1] \"#{RinRuby_Eval_Flag}\""
+      if line == "[1] \"#{RinRuby_Eval_Flag}\""
+        found_eval_flag = true
+        echo_eligible = false
+      end
+      if line == "Warning: #{RinRuby_Stderr_Flag}"
+        found_stderr_flag = true
+        echo_eligible = false
+      end
+      break if found_eval_flag && ( found_stderr_flag == @echo_stderr )
       return false if line == RinRuby_Exit_Flag
-      if echo_enabled
+      if echo_enabled && echo_eligible
         puts line
         $stdout.flush
       end
@@ -244,11 +260,6 @@ class RinRuby
     raise "The 'prompt' method only available in 'interactive' mode" if ! @interactive
     return false if ! eval("0",false)
     prompt = regular_prompt
-    if @platform =~ /windows/
-      eval("#{RinRuby_Null_File} <- file('NUL','w')",false)
-    else
-      eval("#{RinRuby_Null_File} <- file('/dev/null','w')",false)
-    end
     while true
       cmds = []
       while true
@@ -260,19 +271,24 @@ class RinRuby
           cmd = gets.strip
         end
         cmds << cmd
-        parse_okay = complete?(cmds)
-        if parse_okay
+        begin
+          if complete?(cmds.join("\n"))
+            prompt = regular_prompt
+            break
+          else
+            prompt = continue_prompt
+          end
+        rescue
+          puts "Parse error"
           prompt = regular_prompt
+          cmds = []
           break
-        else
-          prompt = continue_prompt
         end
       end
+      next if cmds.length == 0
       break if cmds.length == 1 && cmds[0] == "exit()"
-      break if ! eval(cmds,true)
+      break if ! eval(cmds.join("\n"),true)
     end
-    eval("close(#{RinRuby_Null_File})
-          rm(#{RinRuby_Null_File})",false)
     true
   end
 
@@ -321,15 +337,13 @@ class RinRuby
 #
 #Some care is needed when using the short-hand of the assign method since the label (i.e., people in this case) must be a valid method name in Ruby. For example, R.copy.of.names = names will not work, but R.copy_of_names = names is permissible.
 #
-#The assign method supports Ruby variables of type Fixnum (i.e., integer), Float (i.e., double), String, and arrays of one of those three fundamental types. Data in other formats must be coerced when copying to R.
+#The assign method supports Ruby variables of type Fixnum (i.e., integer), Bignum (i.e., integer), Float (i.e., double), String, and arrays of one of those three fundamental types. Note that Fixnum or Bignum values that exceed the capacity of R's integers are silently converted to doubles.  Data in other formats must be coerced when copying to R.
 #
 #<b>Parameters that can be passed to the assign method:</b>
 #
 #* name: The name of the variable desired in R.
 #
-#* value: The value the R variable should have. The assign method supports Ruby variables of type Fixnum (i.e., integer), Float (i.e., double), String, and arrays of one of those three fundamental types. Data in other formats must be coerced when copying to R.
-#
-#* as_integer: Numerical variables in R are stored as doubles by default, but R provides the ability to have vectors of integers. A vector of integers may be required when interfacing between programs such as R, Fortran, C, or C++. Setting as_integer to true will specify that the value should be type cast into integers. The default is false.
+#* value: The value the R variable should have. The assign method supports Ruby variables of type Fixnum (i.e., integer), Bignum (i.e., integer), Float (i.e., double), String, and arrays of one of those three fundamental types.  Note that Fixnum or Bignum values that exceed the capacity of R's integers are silently converted to doubles.  Data in other formats must be coerced when copying to R.
 #
 #The assign method is an alternative to the simplified method, with some additional flexibility. When using the simplified method, the parameters of name and value are automatically used, in other words:
 #
@@ -340,64 +354,15 @@ class RinRuby
 #      >> R.assign("test",144)
 #
 #Of course it would be confusing to use the shorthand notation to assign a variable named eval, echo, or any other already defined function. RinRuby would assume you were calling the function, rather than trying to assign a variable.
+#
+#Ruby supports arrays containing elements with different types, but in R all the elements of a vector must be of the same type. When assigning an array containing differing types of variables, RinRuby will follow R’s conversion conventions. An array that contains any Strings will result in a character vector in R. If the array does not contain any Strings, but it does contain a Float or a large integer (in absolute value), then the result will be a numeric vector of Doubles in R. If there are only integers that are suffciently small (in absolute value), then the result will be a numeric vector of integers in R.
 
-  def assign(name, value, as_integer=false)
-    if value.kind_of?(String)
-      type = RinRuby_Type_String
-      length = 1
-    elsif value.kind_of?(Fixnum) || value.kind_of?(Float)
-      if as_integer
-        value = [ value.to_i ]
-        type = RinRuby_Type_Integer
-      else
-        value = [ value.to_f ]
-        type = RinRuby_Type_Double
-      end
-      length = 1
-    elsif value.kind_of?(Array)
-      begin
-        if value[0].kind_of?(String)
-          eval "#{name} <- character(#{value.length})"
-          for index in 0...value.length
-            assign("#{name}[#{index}+1]",value[index])
-          end
-          return
-        else
-          if as_integer
-            type = RinRuby_Type_Integer
-            value = value.collect { |x| x.to_i }
-          else
-            type = RinRuby_Type_Double
-            value = value.collect { |x| x.to_f }
-          end
-        end
-      rescue
-        raise "Unsupported data type on Ruby's end"
-      end
-      length = value.length
-    else
-      raise "Unsupported data type on Ruby's end"
-    end
-    @writer.puts <<-EOF
-      #{RinRuby_Type_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
-      #{RinRuby_Length_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
-      if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Double} ) {
-        #{name} <- readBin(#{RinRuby_Socket},numeric(),#{RinRuby_Length_Variable},endian="big")
-      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Integer} ) {
-        #{name} <- readBin(#{RinRuby_Socket},integer(),#{RinRuby_Length_Variable},endian="big")
-      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_String} ) {
-        #{name} <- readBin(#{RinRuby_Socket},character(),1,endian="big")
-      } else { }
-      rm(#{RinRuby_Type_Variable},#{RinRuby_Length_Variable})
-    EOF
-    @socket.write([type,length].pack('NN'))
-    if ( type == RinRuby_Type_String )
-      @socket.write(value)
-      @socket.write([0].pack('C'))   # zero-terminated strings
+  def assign(name, value)
+    if assignable?(name)
+      assign_engine(name,value)
     else
-      @socket.write(value.pack( ( type==RinRuby_Type_Double ? 'G' : 'N' )*length ))
+      raise "Parse error"
     end
-    nil
   end
 
 #Data is copied from R to Ruby using the pull method or a short-hand equivalent. The R object x defined with an eval method can be copied to Ruby object copy_of_x as follows:
@@ -437,11 +402,11 @@ class RinRuby
 #      -0.06069
 #      0.7816
 #
-#Notice the use above of the as.numeric function in R. This is necessary since the pull method only supports R vectors of numerics (i.e., integers or doubles) and characters (i.e., strings). Data in other formats must be coerced when copying to Ruby.
+#Notice the use above of the as.numeric function in R. This is necessary since the pull method only supports R vectors which are numeric (i.e., integers or doubles) and character (i.e., strings). Data in other formats must be coerced when copying to Ruby.
 #
 #<b>Parameters that can be passed to the pull method:</b>
 #
-#* string: The name of the variable that should be pulled from R. The pull method only supports R vectors of numerics (i.e., integers or doubles) and characters (i.e., strings). Data in other formats must be coerced when copying to Ruby. 
+#* string: The name of the variable that should be pulled from R. The pull method only supports R vectors which are numeric (i.e., integers or doubles) or character (i.e., strings). The R value of NA is pulled as nil into Ruby. Data in other formats must be coerced when copying to Ruby.
 #
 #* singletons: R represents a single number as a vector of length one, but in Ruby it is often more convenient to use a number rather than an array of length one. Setting singleton=false will cause the pull method to shed the array, while singletons=true will return the number of string within an array.  The default is false.
 #
@@ -454,6 +419,146 @@ class RinRuby
 #      >> puts R.pull("test")
 
   def pull(string, singletons=false)
+    if complete?(string)
+      result = pull_engine(string)
+      if ( ! singletons ) && ( result.length == 1 ) && ( result.class != String )
+        result = result[0]
+      end
+      result
+    else
+      raise "Parse error"
+    end
+  end
+
+#The echo method controls whether the eval method displays output from R and, if echo is enabled, whether messages, warnings, and errors from stderr are also displayed.
+#
+#<b>Parameters that can be passed to the eval method</b>
+#
+#* enable: Setting enable to false will turn all output off until the echo command is used again with enable equal to true. The default is nil, which will return the current setting.
+#
+#* stderr: Setting stderr to true will force messages, warnings, and errors from R to be routed through stdout.  Using stderr redirection is typically not needed for the C implementation of Ruby and is thus not not enabled by default for this implementation.  It is typically necessary for jRuby and is enabled by default in this case.  This redirection works well in practice but it can lead to interleaving output which may confuse RinRuby.  In such cases, stderr redirection should not be used.  Echoing must be enabled when using stderr redirection.
+
+  def echo(enable=nil,stderr=nil)
+    if ( enable == false ) && ( stderr == true )
+      raise "You can only redirect stderr if you are echoing is enabled."
+    end
+    if ( enable != nil ) && ( enable != @echo_enabled )
+      echo(nil,false) if ! enable
+      @echo_enabled = ! @echo_enabled
+    end
+    if @echo_enabled && ( stderr != nil ) && ( stderr != @echo_stderr )
+      @echo_stderr = ! @echo_stderr
+      if @echo_stderr
+        eval "sink(stdout(),type='message')"
+      else
+        eval "sink(type='message')"
+      end
+    end
+    [ @echo_enabled, @echo_stderr ]
+  end
+
+  private
+
+  #:stopdoc:
+  RinRuby_Type_NotFound = -2
+  RinRuby_Type_Unknown = -1
+  RinRuby_Type_Double = 0
+  RinRuby_Type_Integer = 1
+  RinRuby_Type_String = 2
+  RinRuby_Type_String_Array = 3
+  RinRuby_KeepTrying_Variable = ".RINRUBY.KEEPTRYING.VARIABLE"
+  RinRuby_Length_Variable = ".RINRUBY.PULL.LENGTH.VARIABLE"
+  RinRuby_Type_Variable = ".RINRUBY.PULL.TYPE.VARIABLE"
+  RinRuby_Socket = ".RINRUBY.PULL.SOCKET"
+  RinRuby_Variable = ".RINRUBY.PULL.VARIABLE"
+  RinRuby_Parse_String = ".RINRUBY.PARSE.STRING"
+  RinRuby_Eval_Flag = "RINRUBY.EVAL.FLAG"
+  RinRuby_Stderr_Flag = "RINRUBY.STDERR.FLAG"
+  RinRuby_Exit_Flag = "RINRUBY.EXIT.FLAG"
+  RinRuby_Max_Unsigned_Integer = 2**32
+  RinRuby_Half_Max_Unsigned_Integer = 2**31
+  RinRuby_NA_R_Integer = 2**31
+  RinRuby_Max_R_Integer = 2**31-1
+  RinRuby_Min_R_Integer = -2**31+1
+  #:startdoc:
+
+  def to_signed_int(y)
+    if y.kind_of?(Integer)
+      ( y > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-y) : ( y == RinRuby_NA_R_Integer ? nil : y )
+    else
+      y.collect { |x| ( x > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-x) : ( x == RinRuby_NA_R_Integer ? nil : x ) }
+    end
+  end
+
+  def assign_engine(name, value)
+    original_value = value
+    if value.kind_of?(String)
+      type = RinRuby_Type_String
+      length = 1
+    elsif value.kind_of?(Integer)
+      if ( value >= RinRuby_Min_R_Integer ) && ( value <= RinRuby_Max_R_Integer )
+        value = [ value.to_i ]
+        type = RinRuby_Type_Integer
+      else
+        value = [ value.to_f ]
+        type = RinRuby_Type_Double
+      end
+      length = 1
+    elsif value.kind_of?(Float)
+      value = [ value.to_f ]
+      type = RinRuby_Type_Double
+      length = 1
+    elsif value.kind_of?(Array)
+      begin
+        if value.any? { |x| x.kind_of?(String) }
+          eval "#{name} <- character(#{value.length})"
+          for index in 0...value.length
+            assign_engine("#{name}[#{index}+1]",value[index])
+          end
+          return original_value
+        elsif value.any? { |x| x.kind_of?(Float) }
+          type = RinRuby_Type_Double
+          value = value.collect { |x| x.to_f }
+        elsif value.all? { |x| x.kind_of?(Integer) }
+          if value.all? { |x| ( x >= RinRuby_Min_R_Integer ) && ( x <= RinRuby_Max_R_Integer ) }
+            type = RinRuby_Type_Integer
+          else
+            value = value.collect { |x| x.to_f }
+            type = RinRuby_Type_Double
+          end
+        else
+          raise "Unsupported data type on Ruby's end"
+        end
+      rescue
+        raise "Unsupported data type on Ruby's end"
+      end
+      length = value.length
+    else
+      raise "Unsupported data type on Ruby's end"
+    end
+    @writer.puts <<-EOF
+      #{RinRuby_Type_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
+      #{RinRuby_Length_Variable} <- readBin(#{RinRuby_Socket},integer(),1,endian="big")
+      if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Double} ) {
+        #{name} <- readBin(#{RinRuby_Socket},numeric(),#{RinRuby_Length_Variable},endian="big")
+      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_Integer} ) {
+        #{name} <- readBin(#{RinRuby_Socket},integer(),#{RinRuby_Length_Variable},endian="big")
+      } else if ( #{RinRuby_Type_Variable} == #{RinRuby_Type_String} ) {
+        #{name} <- readBin(#{RinRuby_Socket},character(),1,endian="big")
+      } else { }
+      rm(#{RinRuby_Type_Variable},#{RinRuby_Length_Variable})
+    EOF
+    @socket.write([type,length].pack('NN'))
+    if ( type == RinRuby_Type_String )
+      @socket.write(value)
+      @socket.write([0].pack('C'))   # zero-terminated strings
+    else
+      @socket.write(value.pack( ( type==RinRuby_Type_Double ? 'G' : 'N' )*length ))
+    end
+    original_value
+  end
+
+  def pull_engine(string)
     @writer.puts <<-EOF
       #{RinRuby_Variable} <- try(#{string})
       if ( inherits(#{RinRuby_Variable},"try-error") ) {
@@ -510,64 +615,26 @@ class RinRuby
     else
       raise "Unsupported data type on Ruby's end"
     end
-    if ( ! singletons ) && ( result.length == 1 ) && ( result.class != String )
-      result = result[0]
-    end
     result
   end
 
-#The echo method controls whether the eval method displays output from R.
-#
-#<b>Parameters that can be passed to the eval method</b>
-#
-#* enable: Setting enable to false will turn all output off until the echo command is used again with enable equal to true. Warnings are still sent to the output. The default is nil, which will return the current setting.
-
-  def echo(enable=nil)
-    @echo_enabled = enable if enable != nil
-    @echo_enabled
-  end
-
-  private
-
-  #:stopdoc:
-  RinRuby_Type_NotFound = -2
-  RinRuby_Type_Unknown = -1
-  RinRuby_Type_Double = 0
-  RinRuby_Type_Integer = 1
-  RinRuby_Type_String = 2
-  RinRuby_Type_String_Array = 3
-  RinRuby_Length_Variable = "RINRUBY.PULL.LENGTH.VARIABLE"
-  RinRuby_Type_Variable = "RINRUBY.PULL.TYPE.VARIABLE"
-  RinRuby_Socket = "RINRUBY.PULL.SOCKET"
-  RinRuby_Variable = "RINRUBY.PULL.VARIABLE"
-  RinRuby_Eval_Flag = "RINRUBY.EVAL.FLAG"
-  RinRuby_Exit_Flag = "RINRUBY.EXIT.FLAG"
-  RinRuby_Max_Unsigned_Integer = 2**32
-  RinRuby_Half_Max_Unsigned_Integer = 2**31
-  RinRuby_Parse_Variable = "RINRUBY.PARSE.VARIABLE"
-  RinRuby_Commands_Vector = "RINRUBY.COMMANDS.VECTOR"
-  RinRuby_Null_File = "RINRUBY.NULL.FILE"
-  #:startdoc:
-
-  def to_signed_int(y)
-    if y.kind_of?(Integer)
-      ( y > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-y) : y
-    else
-      y.collect { |x| ( x > RinRuby_Half_Max_Unsigned_Integer ) ? -(RinRuby_Max_Unsigned_Integer-x) : x }
-    end
+  def complete?(string)
+    assign_engine(RinRuby_Parse_String,string)
+    result = pull_engine("unlist(lapply(c('.*','^Error in parse.*','^Error in parse.*unexpected end of input.*'),
+      grep,try({parse(text=#{RinRuby_Parse_String}); 1}, silent=TRUE)))")
+    @writer.puts "rm(#{RinRuby_Parse_String})"
+    return true if result.length == 1
+    return false if result.length == 3
+    raise "Parse error"
   end
 
-  def complete?(string)
-    string = [ string ] if ! string.kind_of?(Array)
-    eval("#{RinRuby_Commands_Vector} <- character(#{string.length})",false)
-    string.each_index { |i| assign("#{RinRuby_Commands_Vector}[#{i}+1]",string[i]) }
-    eval("sink(#{RinRuby_Null_File},type='message')
-          #{RinRuby_Parse_Variable} <- parse(text=#{RinRuby_Commands_Vector})
-          sink()",false)
-    okay = pull("ifelse(exists('#{RinRuby_Parse_Variable}'),1,0)") == 1.0
-    eval("rm(#{RinRuby_Parse_Variable})",false) if okay
-    eval("rm(#{RinRuby_Commands_Vector})",false)
-    return okay
+  def assignable?(string)
+    raise "Parse error" if ! complete?(string)
+    assign_engine(RinRuby_Parse_String,string)
+    result = pull_engine("as.integer(ifelse(inherits(try({eval(parse(text=paste(#{RinRuby_Parse_String},'<- 1')))}, silent=TRUE),'try-error'),1,0))")
+    @writer.puts "rm(#{RinRuby_Parse_String})"
+    return true if result == [0]
+    raise "Parse error"
   end
 
   def find_R_on_windows(cygwin)
@@ -582,7 +649,7 @@ class RinRuby
       end
       break if path != '?'
     end
-    raise 'Cannot locate R executable' if path == '?'
+    raise "Cannot locate R executable" if path == '?'
     if cygwin
       path = `cygpath '#{path}'`
       while path.chomp!

metadata

@@ -1,50 +1,54 @@
---- !ruby/object:Gem::Specification
-required_ruby_version: !ruby/object:Gem::Requirement
+--- !ruby/object:Gem::Specification 
+required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - '>='
-    - !ruby/object:Gem::Version
-      version: !str 0
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 email: rinruby@ddahl.org
 cert_chain: []
+
 summary: Accessing the R interpreter from pure Ruby
 post_install_message: 
 extra_rdoc_files: []
+
 homepage: http://rinruby.ddahl.org
 signing_key: 
 name: rinruby
 rdoc_options: []
+
 autorequire: 
 rubyforge_project: rinruby
 executables: []
+
 description: 
 specification_version: 2
 default_executable: 
 files: 
-- lib/rinruby
 - lib/rinruby.rb
-- lib/rinruby/gif.rb
-- lib/rinruby/animation.rb
 - README.txt
-required_rubygems_version: !ruby/object:Gem::Requirement
+required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - '>='
-    - !ruby/object:Gem::Version
-      version: !str 0
+    - !ruby/object:Gem::Version 
+      version: "0"
   version: 
 extensions: []
+
 rubygems_version: 1.2.0
 requirements: 
 - R (http://www.r-project.org), an environment for statistical computing and graphics
 authors: 
 - David B. Dahl
-date: 2008-08-20 05:00:00 +00:00
+date: 2008-11-17 06:00:00 +00:00
 platform: ruby
 test_files: []
-version: !ruby/object:Gem::Version
-  version: 1.0.1
+
+version: !ruby/object:Gem::Version 
+  version: 1.1.0
 require_paths: 
 - lib
 dependencies: []
+
 bindir: bin
 has_rdoc: true

data/lib/rinruby/animation.rb

@@ -1,74 +0,0 @@
-require 'rinruby'
-
-class Animation < RinRuby
-
-  Graphics_Drivers = ['pdf','swf']
-
-  def loop(n)
-    (1..n).each do |i|
-      print "#{100*i/n}% "
-      eval yield(i)
-    end
-    puts
-  end
-
-  def graphics(filename=nil)
-    if ! filename
-      eval "dev.off()",false
-      if @graphics_driver == 'swf'
-        system <<-EOF
-          pdf2swf -bl -o #{@filename}.swf #{@filename}.pdf > /dev/null 2>&1
-          swfdump --html #{@filename}.swf > #{@filename}.html
-          rm #{@filename}.pdf
-        EOF
-      end
-    else
-      graphics if pull("length(dev.list())") > 0
-      begin
-        @graphics_driver = filename[(filename.rindex('.')+1)..-1].downcase
-      rescue
-        raise "File extension must be in [ #{Graphics_Drivers.join(', ')} ]"
-      end
-      if ! Graphics_Drivers.include?(@graphics_driver)
-        raise "File extension must be in [ #{Graphics_Drivers.join(', ')} ]"
-      end
-      @filename = filename[0...filename.rindex('.')]
-      if @graphics_driver == 'pdf'
-        eval "pdf(paste('#{@filename}.pdf'))"
-      elsif @graphics_driver == 'swf'
-        eval "pdf(paste('#{@filename}.pdf'))"
-      end
-    end
-  end
-
-  def quit
-    graphics if pull("length(dev.list())") > 0
-  end
-
-end
-
-if $0 == __FILE__
-
-  A = Animation.new
-
-  A.graphics "example1.swf"
-  n = 40
-  A.eval "x <- rnorm(#{n})"
-  A.loop(n) do |i|
-    "plot(x[1:#{i}],xlim=c(1,#{n}),ylim=max(abs(x))*c(-1,1),type='l',ylab='')"
-  end
-
-  A.graphics "example2.pdf"
-  A.eval <<-EOF
-      plot(1,type="n",axes=FALSE,xlab="",ylab="")
-      text(1,1,"Thanks!")
-    EOF
-  A.eval <<-EOF
-      plot(1,type="n",axes=FALSE,xlab="",ylab="")
-      text(1,1,"Thanks a lot!")
-    EOF
-
-  A.quit
-
-end
-

data/lib/rinruby/gif.rb

@@ -1,70 +0,0 @@
-require 'rinruby'
-
-class GIF
-
-  def initialize(r_interpreter,filename)
-    @r = r_interpreter
-    @filename = filename
-    @frame_counter = 0
-  end
-
-  def self.draw(r_interpreter,filename,delay)
-    echo = r_interpreter.echo
-    r_interpreter.echo false
-    animated = self.new(r_interpreter,filename)
-    yield(animated)
-    animated.close(delay)
-    r_interpreter.echo echo
-  end
-
-  def add(statement)
-    @frame_counter += 1
-    filename = name(@frame_counter)
-    @r.eval <<-EOF
-      png(paste('#{filename}.png'))
-      #{statement}
-      dev.off()
-    EOF
-    system "convert #{filename}.png #{filename}.gif"
-    File.delete "#{filename}.png"
-  end
-
-  def loop(n)
-    (1..n).each do |i|
-      puts "#{100*i/n}%"
-      add(yield(i))
-    end
-  end
-
-  def close(delay)
-    system "gifsicle -O2 --delay #{delay} #{@filename}-*.gif > #{@filename}.gif"
-    if @frame_counter > 0
-      (1..@frame_counter).each { |i| File.delete("#{name(i)}.gif") }
-    end
-  end
-
-  private
-
-  def name(index)
-    sprintf("%s-%016x",@filename,index)
-  end
-
-end
-
-if $0 == __FILE__
-
-  n = 40
-  R.eval "x <- rnorm(#{n})"
-
-  GIF.draw(R,'time-series',5) do |a|
-    a.loop(n) do |i|
-      "plot(x[1:#{i}],xlim=c(1,#{n}),ylim=max(abs(x))*c(-1,1),type='l',ylab='')"
-    end
-    a.add <<-EOF
-      plot(1,type="n",axes=FALSE,xlab="",ylab="")
-      text(1,1,"Thanks!")
-    EOF
-  end
-
-end
-