galaaz 0.4.6 → 0.5.0

data/lib/R_interface/r.rb

@@ -23,7 +23,7 @@
 
 # Load required R libraries
 dir = File.dirname(File.expand_path('.', __FILE__))
-Polyglot.eval_file("#{dir}/r_libs.R")
+Polyglot.eval_file('R', "#{dir}/r_libs.R")
 
 require_relative 'robject'
 require_relative 'rsupport'
@@ -64,7 +64,7 @@ module R
 
   def self.install_rlibs(*libs)
 
-    packages = R.c(libs)
+    packages = R.c(*libs)
 
     new_packages = packages[!(packages._ :in, R.installed__packages[:all, "Package"])]
     

data/lib/R_interface/r_libs.R

@@ -1,9 +1,14 @@
-list.of.packages <- c('rlang', 'purrr', 'formula.tools', 'lobstr')
+list.of.packages <- c('rlang', 'purrr', 'formula.tools', 'lobstr', 'rticles')
 
 new.packages <- list.of.packages[!(list.of.packages %in% installed.packages()[,"Package"])]
 if(length(new.packages)) install.packages(new.packages)
 
+if (!('data.table' %in% installed.packages()[, "Package"])) {
+  install.fastr.packages('data.table')
+}
+
 library('formula.tools')
 library('lobstr')
 library('rlang')
 library('purrr')
+

data/lib/R_interface/r_methods.rb

@@ -80,8 +80,8 @@ module R
 
     def self.dbk_index
       Polyglot.eval("R", <<-R)
-        function(obj, index) {
-          obj[[index]]
+        function(obj, ...) {
+          obj[[...]]
         }
       R
     end
@@ -171,6 +171,16 @@ module R
         R
     end
 
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
+    Polyglot.eval("R", <<-R)
+      plot = function(...) {
+        print("Function 'plot' is not implemented in fastR.  Please, use ggplot instead")
+      }
+    R
+
   end
   
 end

data/lib/R_interface/rdata_frame.rb

@@ -23,9 +23,9 @@
 
 module R
 
-  class DataFrame < List
+  class DataFrame < Object
+    include IndexedObject
     include MDIndexedObject
-    include Enumerable
 
     #--------------------------------------------------------------------------------------
     # Calls the R.qplot adding the data: parameter
@@ -51,13 +51,16 @@ module R
     # values, for ex., R.c(2, 3, 5)
     #--------------------------------------------------------------------------------------
 
-    def []=(index, values)
-
+    def []=(index, *args)
+      values = args[-1]
+      idx2 = (args.size > 1)? args[-2] : false
+      
       # dealing with double indexing function '[['
       if (index.is_a? Array)
         setR_name("`[[<-`", R.empty_symbol, *index, values)
       else
-        setR_name("`[<-`", R.empty_symbol, index, values)
+        idx2 ? setR_name("`[<-`", index, idx2, values) :
+          setR_name("`[<-`", R.empty_symbol, index, values)
       end
       
       self
@@ -94,18 +97,6 @@ module R
       
     end
 
-#=begin    
-    #--------------------------------------------------------------------------------------
-    # @TODO Need to understand why to_ary is being called here and what the effect is of
-    # returning the empty array.  For now, doing this returns better error messages in
-    # rspec
-    #--------------------------------------------------------------------------------------
-
-    def to_ary
-      []
-    end
-#=end
-
   end
   
 end

data/lib/R_interface/rindexed_object.rb

@@ -38,8 +38,7 @@ module R
 
       # dealing with double indexing function '[['
       if (index.is_a? Array)
-        R::Support.exec_function(R::Support.dbk_index, @r_interop,
-                                 R.internal_eval(:c, *index))
+        R::Support.exec_function(R::Support.dbk_index, @r_interop, *index)
       else
         R::Support.exec_function_name("`[`", @r_interop, index)
       end

data/lib/R_interface/rlist.rb

@@ -29,6 +29,7 @@ module R
 
   class List < Object
     include IndexedObject
+    include Enumerable
     
     #--------------------------------------------------------------------------------------
     #

data/lib/R_interface/robject.rb

@@ -65,16 +65,6 @@ module R
       R::Support.exec_function_name("`==`", @r_interop,
                                     R::Support.parse_arg(other_object))
     end
-
-    #--------------------------------------------------------------------------------------
-    # @TODO: rspec sometimes calls to_ary when an expected value is false.  I still don't
-    # understand this call.  Returning an array with a number inside seems to make
-    # rspec happy, however this could have other consequences I don't know of. 
-    #--------------------------------------------------------------------------------------
-
-    def to_ary
-      [1]
-    end
     
     #--------------------------------------------------------------------------------------
     # @param r_interop [Interop] pointer to an R object
@@ -133,29 +123,28 @@ module R
       end
 
     end
-    
-=begin
-    #--------------------------------------------------------------------------------------
-    # This method was moved to DataFrame.  Need to check which other objects can have
-    # values assigned to them
-    #--------------------------------------------------------------------------------------
 
-    def method_missing_assign(column_name, arg)
-      return setR_name("`[<-`", R.empty_symbol, column_name, arg)
-    end
-=end
     #--------------------------------------------------------------------------------------
     #
     #--------------------------------------------------------------------------------------
 
     def method_missing(symbol, *args, &block)
-
       name = R::Support.convert_symbol2r(symbol)
 
       # Need to raise a NoMethodError when method_missing is called by an implicit
-      # call to "to_ary".  I'm not sure why "to_ary" is being called, but it is
+      # call to "to_ary".  The explanation for that is:
+      # Okay, I've found the source of the behaviour. IOOperations.puts will attempt to
+      # coerce an argument to an array and print its contents, and R::Vector responds to
+      # to_ary but returns the empty array which results in no output.
+      #
+      # Previously IOOperations.puts only checked the type of the argument, and did not
+      # attempt coercion, but that meant we didn't match MRI's behaviour and had some test
+      # failures in other gems. I'd suggest either removing the to_ary methods on
+      # R::Object and R::Vector or implementing them more fully. I see from the comments on
+      # those methods that you needed them for RSpec, it might worth seeing if those problems
+      # still occur and we can look a better way to resolve those.      
       raise NoMethodError if name == "to_ary"
-      
+
       case
       when block_given?
         R::Support.new_scope(symbol, self, *args, &block)
@@ -331,6 +320,14 @@ module R
     #
     #--------------------------------------------------------------------------------------
 
+    def pretty_print(obj)
+      puts self
+    end
+    
+    #--------------------------------------------------------------------------------------
+    #
+    #--------------------------------------------------------------------------------------
+
     def to_s
 
       begin

data/lib/R_interface/rpkg.rb

@@ -28,16 +28,26 @@ module R
   # 
   #----------------------------------------------------------------------------------------
 
-  class Pkg
+  class Package
 
-    def initialize(pkg_name)
-      @pkg_name = pkg_name
+    @@packages = {}
+    
+    def self.[](package_name)
+      return @@packages[package_name] if @@packages.has_key?(package_name)
+      @@packages[package_name] = new(package_name)
     end
 
+    def initialize(package_name)
+      @package_name = package_name
+    end
+    
     def method_missing(symbol, *args)
-      p "execute #{@pkg_name}.#{symbol}(#{args})"
+      symbol = R::Support.convert_symbol2r(symbol)
+      R::Support.exec_function_name("#{@package_name}::#{symbol}", *args)
     end
 
+    private_class_method :new
+    
   end
   
   #----------------------------------------------------------------------------------------
@@ -45,8 +55,7 @@ module R
   #----------------------------------------------------------------------------------------
 
   def self.const_missing(name)
-    p name
-    Pkg.new(name)
+    R::Package[name.to_s.downcase]
   end
 
 end

data/lib/R_interface/rsupport.rb

@@ -29,7 +29,7 @@ module R
   # as [x, ].  What follows the ',' is an empty_symbol.  Whenever we use in Ruby the
   # :all symbol, it will be converted to an empty_symbol in R.
   #--------------------------------------------------------------------------------------
-  
+=begin  
   @@empty_symbol = Polyglot.eval("R", <<-R)
     __missing_arg = quote(f(,0));
     __missing_arg[[2]]
@@ -38,7 +38,12 @@ module R
   def self.empty_symbol
     @@empty_symbol
   end
+=end
 
+  def self.empty_symbol
+    Polyglot.eval("R", "missing_arg()")
+  end
+  
   # When evaluating to NA, Interop treats it as FALSE.  This breaks all expectations
   # about NA.  We need to protect NA from Interop unboxing.  Class NotAvailable
   # puts a list around NA, so that no unboxing occurs.
@@ -63,24 +68,17 @@ module R
     # and allows for debugging.  Use it in exec_function when debugging is needed.
     @@exec_from_ruby = Polyglot.eval("R", <<-R)
       function(build_method, ...) {
-        # print(build_method);
-        # print("exec_from_ruby");
-        # args = list(...);
-        # print(args);
-
         # function 'invoke' from package rlang should do a cleaner than
         # do.call (this is what the documentation says).
         # res = do.call(...);
         res = invoke(...);
-        
-        # print(res);
         res2 = build_method(res);
-        # print(res2);
         res2
       }
     R
         
     #----------------------------------------------------------------------------------------
+    # @TODO: Fix the 'rescue' clause and open issue with fastR
     # Evaluates an R code
     # @param string [String] A string of R code that can be correctly parsed by R
     #----------------------------------------------------------------------------------------
@@ -211,8 +209,6 @@ module R
     
     #----------------------------------------------------------------------------------------
     # @param function [R function (Interop)] R function to execute
-    # @param internal [Boolean] true if returning to an internal object, i.e., does not
-    # wrap the return object in a Ruby object
     # @args [Array] Array of arguments for the function
     #----------------------------------------------------------------------------------------
     
@@ -237,28 +233,26 @@ module R
           res = @@exec_from_ruby.call(R::Object.method(:build), function, pl)
           # R::Object.build(R::Support.eval("do.call").call(function, pl))
         end
-        
+
         @@exec_counter = @@exec_counter - 1
         
         # When execution counter back to 0, print the captured output if the length
         # of the output is greater than 0
         if (@@exec_counter == 0)
           R::Support.stop_capture.call(@@con)
-=begin          
           if (R::Support.eval("length(r_capture) > 0")[0])
             cap = R::Object.build(R::Support.eval("r_capture"))
             (0...cap.size).each do |i|
-              puts cap << i
+              puts cap >> i
             end
           end
-=end          
         end
-        
+
       rescue StandardError => e
-        R::Support.stop_capture.call(@@con)
+        R::Support.stop_capture.call(@@con) if (@@exec_counter == 0)
         raise e
       end
-      
+
       res
       
     end
@@ -270,7 +264,7 @@ module R
     
     def self.exec_function_name(function_name, *args)
       # @TODO: should check all that can go wrong when calling eval(function_name) to
-      # raise the proper exception
+      # raise the proper exception      
       f = R::Support.eval(function_name)
       R::Support.exec_function(f, *args)
     end

data/lib/R_interface/ruby_extensions.rb

@@ -161,14 +161,6 @@ class Symbol
   def assign2(expression)
     exec_bin_oper("`=`", expression)
   end
-
-  #--------------------------------------------------------------------------------------
-  #
-  #--------------------------------------------------------------------------------------
-
-  def [](index)
-    exec_bin_oper("`[[`", index)
-  end
   
   #--------------------------------------------------------------------------------------
   #
@@ -176,18 +168,22 @@ class Symbol
 
   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)
+    E.send(symbol.to_s, self, *args)
     
   end
 
   #--------------------------------------------------------------------------------------
-  #
+  # Used when selecting column in a data frame, from the first column to the var2
+  # column
+  #--------------------------------------------------------------------------------------
+  
+  def up_to(var2)
+    R::Support.exec_function(R::Support.range, self, var2)
+  end
+
+  
+  #--------------------------------------------------------------------------------------
+  # Create an interaction between two variables in formulas
   #--------------------------------------------------------------------------------------
   
   def inter(var2)
@@ -204,7 +200,7 @@ class Symbol
   #--------------------------------------------------------------------------------------
 
   def to_ary
-    [self.to_s]
+    # [self.to_s]
   end
-  
+
 end

data/lib/R_interface/rvector.rb

@@ -115,18 +115,6 @@ module R
       puts "comparison called"
     end
 
-#=begin    
-    #--------------------------------------------------------------------------------------
-    # @TODO Need to understand why to_ary is being called here and what the effect is of
-    # returning the empty array.  For now, doing this returns better error messages in
-    # rspec
-    #--------------------------------------------------------------------------------------
-
-    def to_ary
-      []
-    end
-#=end
-    
   end
   
 end

data/lib/gknit.rb

@@ -27,3 +27,5 @@ require_relative 'gknit/knitr_engine'
 require_relative 'gknit/ruby_engine'
 require_relative 'gknit/rb_engine'
 require_relative 'gknit/include_engine'
+require_relative 'gknit/draft'
+

data/lib/gknit/draft.rb

@@ -0,0 +1,105 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+ # SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+module GKnit
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+  
+  Polyglot.eval("R", <<-R)
+    ruby_template = function(gem, family, template, type, ...) {
+    print(gem)
+    print(family)
+    print(template)
+    print(type)
+    data_dir = eval.polyglot("ruby", "GKnit")$template_path(gem, family, template)
+    print(data_dir)
+    invoke(type, list(template = "template.tex", pandoc_args = paste0("--data-dir=", data_dir), ...))
+  }
+  R
+
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def self.template_path(gem, family, template)
+    full_filename = Dir.glob("gknit-templates*", base: "#{Gem.default_dir}/gems")
+    template_path = "#{Gem.default_dir}/gems/#{full_filename[0]}/#{family}/#{template}"
+  end
+  
+  #--------------------------------------------------------------------------------------
+  #
+  #--------------------------------------------------------------------------------------
+
+  def self.draft(file:, template:, package: nil,
+                 create_dir: 'default', is_package: true, edit: true)
+    
+    # ignore the file extension if given. It should always be an .Rmd file
+    file_basename = File.basename(file, File.extname(file))
+    file = "#{file_basename}.Rmd"
+    
+    # resolve package file
+    # TODO: if package is a rubygem, then look there somehow
+    if (is_package)
+      template_path =
+        R.system__file("rmarkdown", "templates", template, package: package) >> 0
+      raise "The template '#{template}' was not found in the package '#{package}'" if
+        !(R.nzchar(template_path) >> 0)
+    else
+      full_filename = Dir.glob("gknit-templates*", base: "#{Gem.default_dir}/gems")
+      template_path = "#{Gem.default_dir}/gems/#{full_filename[0]}/#{template}"
+      puts template_path
+      # raise "this is not an R package"
+    end
+
+    # read the template.yaml and confirm it has the right fields
+    template_yaml = File.expand_path("template.yaml", template_path)
+    raise "No 'template.yaml' file found for template '#{template}" if
+      !File.file?(template_yaml)
+
+    template_meta = R::Yaml::yaml__load(R.read_utf8(template_yaml))
+    raise "template.yaml must contain 'name' and 'description' fields" if
+      (template_meta.name.is__null || template_meta.description.is__null) >> 0
+    puts "Creating template:"
+    puts "Template name: #{template_meta.name >> 0}"
+    puts "Description: #{template_meta.description >> 0}"
+
+    if (create_dir == 'default')
+      # check if template asks for new directory
+      create_dir = template_meta.create_dir.isTRUE >> 0
+
+      if (create_dir)
+        raise "The directory '#{file_basename}' already exists" if Dir.exist?(file_basename)
+      end
+      
+    end
+
+    raise "File #{file} already exists" if File.file?("#{file_basename}/#{file}")
+    FileUtils.cp_r("#{template_path}/skeleton", "#{file_basename}")
+    # FileUtils.cp("#{template_path}/resources/template.tex", "#{file_basename}")
+    File.rename("#{file_basename}/skeleton.Rmd", "#{file_basename}/#{file}")
+  end
+  
+end
+