galaaz 0.4.2 → 0.4.5

data/lib/R_interface/rsymbol.rb

@@ -29,23 +29,25 @@ module R
 
   class RSymbol < R::Object
     include BinaryOperators
-    include FormulaBinOp
-    
+    include ExecBinOp
+    # include FormulaBinOp
+=begin    
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
     
     def =~(other_object)
       # puts "doing #{self} =~ #{other_object}"
-      exec_oper("`~`", other_object, true)
+      exec_bin_oper("`~`", other_object, true)
     end
+=end
 
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
     
     def ^(other_object)
-      exec_oper("`:`", other_object)
+      exec_bin_oper("`:`", other_object)
     end
     
     #--------------------------------------------------------------------------------------
@@ -54,5 +56,4 @@ module R
 
   end
   
-
 end

data/lib/R_interface/ruby_extensions.rb

@@ -25,6 +25,54 @@
 #
 #==========================================================================================
 
+module R
+
+  module ExpBinOp
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def exec_bin_oper(operator, other_object)
+      R::Support.exec_function(R::Support.create_bin_expr(operator), self,
+                               other_object)
+    end
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    def coerce(numeric)
+      [R::RubyExpression.build_bin_exp(numeric), self]
+    end
+
+  end
+  
+end
+
+#==========================================================================================
+#
+#==========================================================================================
+
+module E
+
+  #----------------------------------------------------------------------------------------
+  # @param symbol [Symbol]
+  # @param args [Array] arguments to the missing method
+  #----------------------------------------------------------------------------------------
+  
+  def self.method_missing(symbol, *args)
+    name = R::Support.convert_symbol2r(symbol)
+    rargs = R.exprs(name.to_sym, *args)    
+    R.as__call(rargs)
+  end
+  
+end
+
+#==========================================================================================
+#
+#==========================================================================================
+
 class Range
 
   #----------------------------------------------------------------------------------------
@@ -32,7 +80,11 @@ class Range
   #----------------------------------------------------------------------------------------
   
   def -@
-    NegRange.new(self.begin, self.end)
+    final_value = (exclude_end?)?
+                    (first > last)?
+                      (last + 1) : (last - 1)
+                  : last
+    NegRange.new(self.begin, final_value)
   end
 
 end
@@ -53,15 +105,14 @@ end
 
 class Symbol
   include R::BinaryOperators
-  include R::CallBinOp
+  include R::ExpBinOp
 
   #--------------------------------------------------------------------------------------
   # Unary '+' converts a Ruby Symbol into an R Symbol
   #--------------------------------------------------------------------------------------
 
   def +@
-    var = (self == :all)? '.' : to_s
-    R::Object.build(R::Support.eval("as.name").call(var))
+    R.expr(self)
   end
 
   #--------------------------------------------------------------------------------------
@@ -71,5 +122,80 @@ class Symbol
   def ~@
     R::Object.build(R::Support.eval(to_s))
   end
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def succ
+    self.to_s.succ.to_sym
+  end
+  
+  #----------------------------------------------------------------------------------------
+  # We use the following notation to access binary R functions such as %in%:
+  # R.vec_ "in", list.
+  # @param args [Array] The first element of the array is an R infix function, the other
+  # arguments are the list of arguments for the function.
+  #----------------------------------------------------------------------------------------
+  
+  def _(*args)
+    name = "%#{args.shift.to_s}%"
+    args.unshift(self)
+    rargs = R.exprs(name, *args)
+    R.as__call(rargs)
+  end
+  
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def assign(expression)
+    exec_bin_oper("`<-`", expression)
+  end
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def [](index)
+    exec_bin_oper("`[[`", index)
+  end
+  
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def method_missing(symbol, *args, &block)
+
+    if (symbol =~ /(.*)=$/)
+      # method_missing_assign($1, args[0])
+    elsif (args.length == 0 && ((R.c(symbol.to_s)._ :in, R.names(self)) << 0))
+      return self[symbol.to_s]
+    end
+    
+    R.send(symbol.to_s, self, *args)
+    
+  end
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+  
+  def inter(var2)
+    R::Support.exec_function(R::Support.range, self, var2)
+  end
+  
+  #--------------------------------------------------------------------------------------
+  # If method_missing is implemented, then we also need to implement method 'to_ary'.
+  # This is because starting from ruby 1.9 the code for Array#flatten has changed,
+  # calling 'to_ary' blindly (even if the method is not implemented).  This causes
+  # the method to be caught by 'method_missing' and here sending a 'to_ary' no found
+  # error.  If we create to_ary, then no error is issued.
+  # @TODO: make sure that implementing 'to_ary' as bellow will not create problems
+  #--------------------------------------------------------------------------------------
+
+  def to_ary
+    [self.to_s]
+  end
   
 end

data/lib/R_interface/runary_operators.rb

@@ -23,6 +23,35 @@
 
 module R
 
+  module ExecUniOp
+
+    #--------------------------------------------------------------------------------------
+    # 
+    #--------------------------------------------------------------------------------------
+
+    def exec_uni_oper(operator)      
+      R::Support.exec_function_name(operator, @r_interop)
+    end
+    
+  end
+
+
+  module ExpUniOp
+
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+    
+    def exec_uni_oper(operator)
+      # op1 = prep(self)
+      # op2 = prep(other_object)      
+      # R::Expression.build(operator, self)
+      optr = operator.delete("`")
+      R::Expression.build("#{operator}#{self}")
+    end
+
+  end
+  
   #--------------------------------------------------------------------------------------
   #
   #--------------------------------------------------------------------------------------
@@ -34,7 +63,8 @@ module R
     #--------------------------------------------------------------------------------------
 
     def !
-      R::Support.exec_function_name("`!`", @r_interop)
+      # R::Support.exec_function_name("`!`", @r_interop)
+      exec_uni_oper("`!`")
     end
     
     #--------------------------------------------------------------------------------------
@@ -42,7 +72,8 @@ module R
     #--------------------------------------------------------------------------------------
 
     def -@
-      R::Support.exec_function_name("`-`", @r_interop)
+      # R::Support.exec_function_name("`-`", @r_interop)
+      exec_uni_oper("`-`")
     end
     
     #--------------------------------------------------------------------------------------
@@ -50,7 +81,8 @@ module R
     #--------------------------------------------------------------------------------------
 
     def +@
-      R::Support.exec_function_name("`+`", @r_interop)
+      # R::Support.exec_function_name("`+`", @r_interop)
+      exec_uni_oper("`+`")
     end
 
   end

data/lib/R_interface/rvector.rb

@@ -28,6 +28,7 @@ module R
     include BinaryOperators
     include ExecBinOp
     include UnaryOperators
+    include ExecUniOp
     include Enumerable
     
     #--------------------------------------------------------------------------------------

data/lib/galaaz.rb

@@ -21,8 +21,6 @@
 # OR MODIFICATIONS.
 ##########################################################################################
 
-require 'pry'
-
 $LOAD_PATH << File.dirname(File.expand_path('..', __FILE__)) + "/r_requires"
 
 require_relative 'R_interface/r'

data/lib/gknit/knitr_engine.rb

@@ -88,11 +88,29 @@ class KnitrEngine
 
   def self.file_ext
     # guess plot file type if it is NULL
-    if (@keep != 'none' && @options.fig__ext.is__null)
-      @options.fig__ext = R.dev2ext(@options.dev)
+    if (((@keep != 'none') << 0) && (@options.fig__ext.is__null << 0))
+      # TODO: allow @options.fig__ext when it is null... confusing otherwise!
+      @options["fig.ext"] = R.knitr_dev2ext(@options.dev)
+      puts @options.fig__ext
     end
   end
+
+  #--------------------------------------------------------------------------------------
+  # 
+  #--------------------------------------------------------------------------------------
+
+  def self.capture_plot
+    
+    plot = R.evaluate_plot_snapshot
+    
+    if (!(R.is__null(plot) << 0))
+      R.png(@filename)
+      R.print(plot)
+      R.dev__off
+    end
     
+  end
+  
   #--------------------------------------------------------------------------------------
   # Process the chunk options
   #--------------------------------------------------------------------------------------
@@ -102,9 +120,15 @@ class KnitrEngine
     
     # verifies if figures should be kept
     fig_keep
-    
+
     # if figures are to be kept, take or guess the file extension
-    # file_ext
+    file_ext
+
+    # puts @keep
+    
+    # make final filename
+    @filename = R.paste0(@options.fig__path, @options.label, ".", @options.fig__ext)
+    
   end
 
   #--------------------------------------------------------------------------------------
@@ -118,3 +142,33 @@ class KnitrEngine
   end
   
 end
+
+
+
+module R
+
+  class Object
+    
+    #--------------------------------------------------------------------------------------
+    # Redefine to_s in order to capture plots when in knitr
+    #--------------------------------------------------------------------------------------
+    
+    def to_s
+
+      cap = nil
+      # dev = R::Device.new('png', width: 5, height: 7, dpi: 300, record: true) {
+      cap = R::Support.capture.call(r_interop)
+      # cap = R::Support.capture_output.call(r_interop)
+      # }
+      str = String.new
+      (0...(cap.size - 1)).each do |i|
+        str << cap[i] << "\n"
+      end
+      str << cap[cap.size - 1] if cap.size >= 1
+      KnitrEngine.capture_plot
+      str
+    end
+
+  end
+  
+end

data/lib/gknit/ruby_engine.rb

@@ -26,9 +26,10 @@ eng_ruby = Proc.new do |options|
 
   begin
     # read the chunk code
-    code = R.paste(options.code, collapse: "\n") << 0
+    # code = R.paste(options.code, collapse: "\n") << 0
     
-    # process the chunk options
+    # process the chunk options. Better to let interested methods process their
+    # options
     KnitrEngine.process_options(options)
 
     tmp_fig = R.tempfile()
@@ -52,15 +53,13 @@ eng_ruby = Proc.new do |options|
     end
     
     # executes the code
-    res = GalaazUtil.exec_ruby(code)
+    res = GalaazUtil.exec_ruby(options)
     
     # formats and outputs the code and results
-    R.engine_output(options, options.code, res)
+    R.engine_output(options, out: res)
 
   ensure
     R.dev__off(dv)
-    # tmp_fig.unlink
-    # if (keep.pars) opts_knit$set(global.pars = par(no.readonly = TRUE))
   end
   
 end

data/lib/util/exec_ruby.rb

@@ -23,22 +23,68 @@
 
 require 'stringio'
 
+#----------------------------------------------------------------------------------------
+# Class RubyChunk is used only as a context for all ruby chunks in the rmarkdown file.
+# This allows for chunks to access instance_variables (@)
+#----------------------------------------------------------------------------------------
+
 class RubyChunk
 
 end
 
+#----------------------------------------------------------------------------------------
+#
+#----------------------------------------------------------------------------------------
+
 module GalaazUtil
+
+  #----------------------------------------------------------------------------------------
+  # Executes the ruby code with the given options.
+  # @param options [R::List] An R list of options
+  # @return [R::List] an R list with everything that needs to be outputed.
+  # The options are:
+  # * options.code: the ruby code
+  # * options[["eval"]]: evaluate if true
+  # * options.echo: if true, show the source code of the chunk in the output
+  # * options.message: if true, show error message if any exception in the ruby code
+  # * options.warning: if true, show stack trace from the ruby code
+  # * options.include: if true, include the code output
+  # Note that we need to access the 'eval' element of the list by indexing as
+  # options[["eval"]], this is because eval is a Ruby function and doing options.eval
+  # will call the eval method on options, which is not what we want
+  #----------------------------------------------------------------------------------------
   
-  def self.exec_ruby(code)
+  def self.exec_ruby(options)
+
+    # read the chunk code
+    code = R.paste(options.code, collapse: "\n") << 0
+
+    out_list = R.list
+    out_list["source"] = code if (options.echo << 0)
     
-    # Set up standard output as a StringIO object.
-    $stdout = StringIO.new
-    RubyChunk.instance_eval(code)
-    out = $stdout.string
-    # return $stdout to standard output
-    $stdout = STDOUT
-    # return everything that was outputed
-    out
+    begin
+      # Set up standard output as a StringIO object.
+      $stdout = StringIO.new
+      RubyChunk.instance_eval(code) if (options[["eval"]] << 0)
+      out = $stdout.string
+      # KnitrEngine.capture_plot
+      
+      # return $stdout to standard output
+      $stdout = STDOUT
+      # return everything that was outputed
+      out_list["text"] = out
+    rescue StandardError => e
+      out_list["message"] = e.message if (options.message << 0)
+      out_list["warning"] = e.backtrace.inspect if (options.warning << 0)
+    end
+
+    # TODO: check the name of procedures since communication is
+    # bidirectional.  The name parse_arg was done thinking only on
+    # the Ruby -> R direction.
+    # exec_ruby returns its output to an R script, so we need to pass
+    # the output (out_list) through parse_arg to make it available
+    # to R.
+    (options.include << 0)? R::Support.parse_arg(out_list) : nil
     
   end