R4rb 1.0.0

data/lib/R4rb/Rserve.rb

@@ -0,0 +1,208 @@
+# encoding: utf-8
+### IMPORTANT, no use of R4rb tools! R2rb or Rserve mode only!
+
+module Rserve
+
+	## server side
+	def Rserve.pid
+		`ps -C Rserve -o pid=`.strip
+	end
+
+	def Rserve.running?
+  		!Rserve.pid.empty?
+  	end
+
+  	def Rserve.start(rserve=File.expand_path("~/bin/Rserv"))
+  		`R CMD #{rserve}` unless Rserve.running?
+  	end
+
+
+	def Rserve.stop
+		pid=Rserve.pid
+  		`kill #{pid}` unless pid.empty?
+  		sleep(2)
+  		if Rserve.running?
+  			puts "Sorry! but the Rserver is still running!"
+  		end
+  	end
+
+  	## client side
+  	@@clients,@@cli=nil,nil
+
+	def Rserve.init
+		#puts "Rserve.init"
+		Array.initR
+		#puts "Rserve.init2"
+		"require(Rserve)".R2rb
+		#puts "Rserve.init3"
+		@@clients,@@cli=[],nil
+		@@out=[]
+		@@out.rb2R=R2rb
+		#puts "Rserve.init4"
+	end
+
+	#####################################################
+	# the two following methods to be possibly redefined
+	# in particular inside Dyndoc to automatically 
+	# allocate the R session related to the user!
+	def Rserve.cli
+		@@cli
+	end
+	#
+	def Rserve.cli=(cli)
+		@@cli=cli
+	end
+	#####################################################
+
+
+	def Rserve.client(cli=nil)
+		## automate the init process!
+		#Rserve.init unless @@clients
+
+		##return current client!
+		unless cli 	
+			return Rserve.cli
+		## create a new client
+		else 		
+			Rserve.open(cli)
+		end
+	end
+
+	## change the current client!
+	def Rserve.client=(cli=nil)
+		return nil unless @@clients.include? cli
+		Rserve.cli=cli
+	end
+
+	def Rserve.open(cli)
+		"#{cli.to_s} <- RSconnect()".R2rb
+		@@clients << cli
+		Rserve.cli=cli
+	end
+
+	def Rserve.close(cli=nil) 
+		cli=Rserve.cli unless cli
+		return unless @@clients.include? cli
+		"RSclose(#{cli.to_s})".R2rb
+		@@clients.delete(cli)
+	end
+
+	def Rserve.ls
+		@@clients
+	end
+
+	#####################################################
+	## interface
+	def Rserve.complete_code!(code)
+		code.gsub!("\\","\\\\")
+		code.gsub!("\"","\\\"")
+		code.replace("RSeval(#{cli},\"capture.output({"+code+"})\")")
+	end
+
+
+	def Rserve.completed_code(code,capture=true)
+		open,close= (capture ? ["capture.output({","})"] : ["",""])
+		"RSeval(#{cli},\""+open+code.gsub("\\","\\\\").gsub("\"","\\\"")+close+"\")"
+	end
+
+	def Rserve.eval(code,cli=nil)
+		cli=Rserve.cli unless cli
+		return nil unless cli
+		## check parsing locally (without RSeval)
+		status=R2rb.parse code
+		if status!=1
+			R2rb.parse code,true
+			return false
+		end
+		## RSeval completed in code!
+		Rserve.complete_code!(code)
+		#puts "Rserve.eval:";p code
+		R2rb.eval code
+		#@@out < code ##@@out.inR2rb code # since @@out < code but for R2rb
+	end
+
+	def Rserve.try_eval(code,cli=nil)
+		cli=Rserve.cli unless cli
+    	try_code=".result_try_code<-try({\n"+code+"\n},silent=TRUE)\n"
+    	puts Rserve.output(try_code,cli).join("\n")
+    	puts R2rb.output(Rserve.completed_code(".result_try_code",false)) if "inherits(.result_try_code,'try-error')".to_R
+  	end
+
+	def Rserve.<<(code)
+		Rserve.eval(code)
+	end
+
+	def Rserve.output(code,cli=nil)
+		#puts "Rserve.output:";p code
+		cli=Rserve.cli unless cli
+		return nil unless cli
+		## RSeval completed in code!
+		Rserve.complete_code!(code)
+		@@out < code ##@@out.inR2rb rcode.to_s
+    	return (@@out.length<=1 ? @@out[0] : @@out)
+	end
+
+	def Rserve.<(code)
+		Rserve.output(code)
+	end
+
+	def Rserve.assign(code,var=nil,cli=nil)
+		code+=",quote(#{var})" if var
+		cli=Rserve.cli unless cli
+		code="RSassign(#{cli},#{code})"
+		#p code
+		#R2rb << code ###????
+		Rserve << code
+	end
+
+	class RVector < R2rb::RVector
+
+		def RVector.assign(var,ary,cli=nil)
+			super(var,ary)
+			Rserve.assign(var,var,cli)
+		end
+
+		attr_accessor :cli
+
+		## The goal is to connect a ruby Array to a Rserve Vector  
+		def initialize(name,cli=nil)
+			@cli=(cli ? cli : Rserve.cli)
+			puts "WARNING: Rserve::RVector.initialize: @cli is null!" unless @cli
+			@name_orig=name
+			super(name!)
+			@type="expr"
+		end
+
+		def name! #name from cli and name_orig
+			##puts "name!";p @name_orig
+			##deb,fin="quote(",")" #(@name_orig=~/^evalq\(/ ? ["quote(",")"] : ["\"","\""])
+			"RSeval(#{@cli},quote(#{@name_orig}))"
+		end
+
+		def <<(name)
+			## no "var" in this context! transform it in String if necessary
+	        @name_orig=name.to_s
+	        super(name!)
+	      	return self
+	    end
+
+	    ## no need to make aby change for ">"
+
+		def <(ary)
+			ary.R2rb(".rubyExport") #transition
+			Rserve.assign(".rubyExport",@name_orig,@cli)
+		end
+
+		alias value= <
+
+		def set_with_arg(ary)
+			ary=[ary] unless ary.is_a? Array
+			ary.R2rb(".rubyExport") #transition
+			#p @name_orig+@arg
+			Rserve.assign(".rubyExport",@name_orig+@arg,@cli)
+		end
+
+		alias value_with_arg= set_with_arg
+
+	end
+end

data/lib/R4rb/converter.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+class String
+
+  def to_aRy(sep=",")
+    self.split(sep).map{|str|
+      R2rb.multilang_parser(str)
+    }.flatten
+  end
+
+end
+
+module R2rb
+
+  @@pair=["<<",">>"]
+
+  def R2rb.pair
+    @@pair
+  end
+
+  def R2rb.pair=(pair)
+    if pair.is_a? String
+      pairs={"{"=>"}","("=>")","<"=>">","["=>"]"}
+      pair2=pair.reverse.gsub(/[#{Regexp.escape(pairs.keys.join)}]/) {|e| Regexp.escape(pairs[e])}
+      pair=[pair,pair2]
+    end
+#p "ICI";p pair
+    if (pair.is_a? Array) and pair.length==2
+      @@pair=pair
+    end
+#p @@pair
+  end
+
+  def R2rb.multilang_parser(str)
+#p @@pair
+    lang="r|R|rb|Rb"
+    s=str
+    if @@pair[0].empty?
+      mask = /((?:#{lang}).*)/
+    else
+      mask = /#{Regexp.escape(@@pair[0])}((?:#{lang})[^#{Regexp.escape(@@pair[0])}]*)#{Regexp.escape(@@pair[1])}/
+    end
+    str=str.split(mask,-1)
+    return s if str.length<=1
+    vals=[]
+    res=[]
+    inds=0..(str.length / 2 - 1)
+    ".tmp<-NULL".to_R 
+    inds.each {|i|
+      res << str[2*i]
+      if str[2*i+1] =~ /^(?:r|R):(.*)/
+        (".tmp<-cbind(.tmp,"+$1+")").to_R
+      end
+      if str[2*i+1] =~ /^(?:rb|Rb):(.*)/
+        a=eval($1)
+        a=[a] unless a.is_a? Array
+        a > :tmp
+        (".tmp<-cbind(.tmp,tmp)").to_R
+     end
+    }
+    res << str[-1]
+#p res
+    cmd="apply(.tmp,1,function(e) paste("
+    inds.each{|i| cmd += "'"+res[i]+"',e["+i.to_s+"+1]," }
+    cmd += "'"+res[-1]+"',sep=''))"
+#"print(.tmp)".to_R
+#p cmd
+    cmd.to_R
+  end
+end

data/lib/R4rb/init.rb

@@ -0,0 +1,127 @@
+##  Attention "...\n..." have to be replaced by "...\\n..."
+## example : 'cat("toto\n")' fails but not 'cat("toto\\n")'
+## more surprisingly, this fails even in comment '# cat("toto\n")'
+
+module R2rb
+
+  def R2rb.init(args=["--save","--slave","--quiet"])
+    @@initR=R2rb.initR(args) unless R2rb.alive?
+  end
+
+  def R2rb.alive?
+    defined? @@initR
+  end
+
+  class RBuffer
+    def initialize
+      @s=String.new
+    end
+    
+    def init
+      R2rb.init
+    end
+    
+    def clear
+      @s=""
+    end
+    
+    def +(s=nil)
+      if s
+      	s=s.to_s unless s.is_a? String
+      	@s += "\n"+s
+      else
+        clear
+      end
+      return self
+    end
+    
+    def exec(aff=nil)
+      R2rb.eval @s,aff
+    end
+  end
+  
+=begin
+ class RVector
+   def <<(name)
+     if name.is_a? Symbol
+       @name=name.to_s
+       @type="var"
+     else
+       @name=name
+       @type="expr"
+     end
+     return self
+   end
+
+   def >(arr)
+     arr.replace(self.get)
+     return self
+   end
+ end
+=end
+
+ class RConsole
+   def initialize
+     require "readline"
+   end
+
+   def init args
+     R2rb.init args
+   end
+
+   def exec
+     #todo : continuation
+     toggle=true
+     fin=false
+     words=[]
+     rvect=R2rb::RVector.new("")
+     Readline.completion_proc=Proc.new {|e|
+       cpt=0
+       begin
+	 begin
+	   cpt += 1
+	   toggle = !toggle
+	   rvect << (toggle ? "apropos(" : "ls(pat=")+"'^"+e+"')" > words
+	   res=words.map{|w| w[Regexp.new("^"+e+".*")]}-[nil]
+	 end while res.empty? and cpt<3
+	 res
+       rescue
+	 warn("\r"+e+" not suitable for completion!!!")
+	 []
+       end
+     }
+     Readline.completion_append_character=""
+     begin
+       line = Readline.readline("R> ", true)
+       if !(fin = line=="quit")
+	 R2rb.eval line,true
+	 toggle=true
+       end
+     end until fin
+   end
+ end
+end
+
+def find_installed_R
+
+  if RUBY_PLATFORM=~/mingw32/
+     ENV["R_HOME"]=`R RHOME`
+  elsif RUBY_PLATFORM=~/darwin/
+    ENV["R_HOME"]=`R RHOME`.strip
+  else
+    dirs=["/usr/lib/R","/usr/local/lib/R","/usr/lib64/R","/usr/local/lib64/R"]
+   
+    dirs.each do |dir|
+      if FileTest.exists?(dir)
+        return dir
+      end
+    end
+
+    raise RuntimeError, "couldn't find R Home : R seems to be uninstalled!!"
+  end
+
+end
+
+ENV["R_HOME"]=`R RHOME`.strip.split("\n").select{|l| l=~/^\//}[0] unless `R RHOME`.empty?
+
+ENV["R_HOME"]=find_installed_R unless ENV["R_HOME"]

data/lib/R4rb/robj.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module RObj
+
+  def RObj.<(rcode)
+    return (R2rb < rcode) 
+  end
+
+  def RObj.class(rname)
+    RObj < "class(#{rname})"
+  end
+
+  def RObj.mode(rcode)
+    RObj < "mode(#{rcode})"
+  end
+
+  # temporary R object saved in ruby object!
+  def RObj.make(rcode,first=true)
+    mode=RObj.mode(rcode)
+    RObj < ".tmpRObj<-(#{rcode})" if first
+    code=(first ? ".tmpRObj" : rcode.dup) 
+    if ['numeric','logical','complex','character'].include?(mode)
+      #if RObj.class(code)=="matrix"
+      return (RObj< rcode)
+    elsif mode=="list"
+      robj={}
+      tmpNames=RObj < "names(#{rcode})"
+      tmpNames.each_with_index do |nam,i|
+         key=(nam.empty? ? i : nam)
+         rkey=(nam.empty? ? i : "\""+nam+"\"")
+         robj[key]=RObj.make("#{rcode}[[#{rkey}]]",false)
+        end
+      return robj
+    else
+      return nil
+    end
+  end
+
+  def RObj.<<(rcode) 
+    RObj.make(rcode)
+  end
+
+  def RObj.exist?(rname)
+    RObj < "exists(\"#{rname}\")"
+  end
+
+end