rust 0.11 → 0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77dee9cb8c4a1e2894a8054fab8dbf140b8f6a4aed8ef38a60b41564fb5e8e69
-  data.tar.gz: c9bf14d2239f464cf73ffaee86bcbfe9155a323269eff1b34b7bcd1272c46d36
+  metadata.gz: 56e795fb0a8893df45abd976e2ed91344156f3c3dd4a68e17afd1a0fb317ece3
+  data.tar.gz: 406416738f1ab84fca06edd5cb59efdc623b12cefe03cd51b1a2cd840e218647
 SHA512:
-  metadata.gz: a648f440574e7734f979c0ec5d65bc9594202cfe88414517dcc50482e391360809ced88bbc0b825f548dfd23dd2b9dfe47b71cabbd216249d992d8a18d14717c
-  data.tar.gz: 1b999d94b96c05a0615ff05b3e1588c4a8e822baebba57055ae041a6fe2c7d0355d747e3c88973c9325046c59c4eff013b27336d95297c8c0e1cc06f515b2f27
+  metadata.gz: 56854c3ff1bbd64ca8ff9d1201bc16fd37f4d3d465527217ab5c49d5cee0d6f4f34998bdf8a3ebdedf7ea8379909ca0db75d05da1bd46460c3e7066ee882ba7b
+  data.tar.gz: 6b21ba70c7d144384d1647dfa76f8894457bf4d65b74ce32d4e775cc3ecdc660f4596f61edd81e91b08c9d2b3def3491cebe10b7923b9f2988d072f7c5d25674

data/lib/rust/core/csv.rb

@@ -90,9 +90,9 @@ module Rust
             dataframe.column_names.each do |column_name|
                 values = dataframe.column(column_name)
                 
-                if values.all? { |s| !!Integer(s) rescue false }
+                if values.all? { |s| s == nil || !!Integer(s) rescue false }
                     integer_columns << column_name
-                elsif values.all? { |s| !!Float(s) rescue false }
+                elsif values.all? { |s| s == nil || !!Float(s) rescue false }
                     float_columns << column_name
                 end
             end
@@ -103,11 +103,11 @@ module Rust
             end
             
             integer_columns.each do |numeric_column|
-                dataframe.transform_column!(numeric_column) { |v| v.to_i }
+                dataframe.transform_column!(numeric_column) { |v| v != nil ? v.to_i : v }
             end
             
             float_columns.each do |numeric_column|
-                dataframe.transform_column!(numeric_column) { |v| v.to_f }
+                dataframe.transform_column!(numeric_column) { |v| v != nil ? v.to_f : v }
             end
             
             return dataframe

data/lib/rust/core/manual.rb

@@ -0,0 +1,89 @@
+require_relative 'rust'
+
+module Rust
+    class Manual
+        @@manuals = {}
+        
+        def self.about
+            puts "Manuals available:"
+            @@manuals.each do |category, manual|
+                puts "\t- #{manual.name} (:#{category}) → #{manual.description}"
+            end
+            
+            return nil
+        end
+        
+        def self.for(category)
+            category = category.to_sym
+            raise "No manual found for '#{category}'." unless @@manuals[category]
+            
+            return @@manuals[category]
+        end
+        
+        def self.register(category, name, description)
+            category = category.to_sym
+            
+            @@manuals[category] = Manual.new(name, description)
+            
+            return nil
+        end
+        
+        attr_reader     :name
+        attr_reader     :description
+        
+        def initialize(name, description)            
+            @name = name
+            @description = description
+            @voices = {}
+        end
+        
+        def lookup(query)
+            @voices.each do |key, value|
+                if query.match(key[1])
+                    puts "*** #{key[0]} ***"
+                    puts value
+                    return
+                end
+            end
+            
+            puts "Voice not found"
+            
+            return nil
+        end
+        
+        def n_voices
+            @voices.size
+        end
+        
+        def about
+            puts "****** Manual for #@name ******"
+            puts @description
+            puts "Voices in manual #@name:"
+            @voices.keys.each do |key, matcher|
+                puts "\t- #{key}"
+            end
+            
+            return nil
+        end
+        
+        def register(voice, matcher, description)
+            @voices[[voice, matcher]] = description
+        end
+        
+        def inspect
+            return "Manual for #@name with #{self.n_voices} voices"
+        end
+    end
+end
+
+module Rust::RBindings
+    def rust_help(category = nil, query = nil)
+        if !category
+            return Rust::Manual.about
+        elsif !query
+            return Rust::Manual.for(category).about
+        else
+            return Rust::Manual.for(category).lookup(query)
+        end
+    end
+end

data/lib/rust/core/rust.rb

@@ -102,7 +102,10 @@ module Rust
     end
     
     def self._rexec(r_command, return_warnings = false)
-        puts "Calling _rexec with command: #{r_command}" if @@debugging
+        if @@debugging
+            puts "Calling _rexec with command: #{r_command}"
+            puts "\t" + Kernel.caller.select { |v| !v.include?("irb") }.last(3).map { |v| v.sub(/^.*gems\//, "")}.join("\n\t")
+        end
         R_MUTEX.synchronize do
             assert("This command must be executed in an exclusive block") { @@in_client_mutex }
             
@@ -154,10 +157,17 @@ module Rust
     
     ##
     # Installs the given +name+ library and its dependencies.
+    # +github+ indicates whether the package is in GitHub.
     
-    def self.install_library(name)
+    def self.install_library(name, github = false)
+        self.prerequisite("remotes") if github
+
         self.exclusive do
-            self._eval("install.packages(\"#{name}\", dependencies = TRUE)")
+            if github
+                self._eval("remotes::install_github(\"#{name}\", dependencies=TRUE)")
+            else
+                self._eval("install.packages(\"#{name}\", dependencies = TRUE)")
+            end
         end
         
         return nil
@@ -165,9 +175,15 @@ module Rust
     
     ##
     # Installs the +library+ library if it is not available and loads it.
+    # +github+ indicates whether the package appears in GitHub.
     
-    def self.prerequisite(library)
-        self.install_library(library) unless self.check_library(library)
+    def self.prerequisite(library, github = false)
+        full_library = library
+        library = library.split("/").last if github
+        
+        unless self.check_library(library)
+            self.install_library(full_library, github)
+        end
         self.load_library(library)
     end
     
@@ -218,4 +234,11 @@ def bind_r!
     include Rust::RBindings
 end
 
+##
+# Shortcut for requiring rust external libraries
+
+def require_rust(name)
+    require "rust/external/#{name}"
+end
+
 bind_r! if ENV['RUBY_RUST_BINDING'] == '1'

data/lib/rust/core/types/dataframe.rb

@@ -1,4 +1,5 @@
 require_relative 'datatype'
+require 'tempfile'
 
 module Rust
     
@@ -355,8 +356,25 @@ module Rust
         end
         
         def load_in_r_as(variable_name)
-            command = []
+            tempfile = Tempfile.new('rust.dfport')
+            tempfile.close
+            
+            Rust::CSV.write(tempfile.path, self)
+            Rust._eval("#{variable_name} <- read.csv(\"#{tempfile.path}\", header=T)")
+            
+            if Rust.debug?
+                FileUtils.cp(tempfile.path, tempfile.path + ".debug.csv")
+                puts "Debug CSV port file available at: #{tempfile.path + ".debug.csv"}"
+            end
+            
+            tempfile.unlink
             
+            return true
+        end
+        
+        def directly_load_in_r_as(variable_name)
+            command = []
+                        
             command << "#{variable_name} <- data.frame()"
             row_index = 1
             self.each do |row|
@@ -374,6 +392,10 @@ module Rust
             end
             
             Rust._eval_big(command)
+            
+            tempfile.unlink
+            
+            return true
         end
         
         def inspect
@@ -408,16 +430,39 @@ module Rust
             return result
         end
         
+        ##
+        # Merges this data-frame with +other+ in terms of the +by+ column(s) (Array or String). Keeps all the rows in this data frame.
+        # +first_alias+ and +second_alias+ allow to specify the prefix that should be used for the columns not in +by+
+        # for this and the +other+ data-frame, respectively.
+        
+        def left_merge(other, by, first_alias, second_alias, **options)
+            options[:keep_right] = true
+            options[:keep_left]  = false
+            return other.merge(self, by, first_alias, second_alias, **options)
+        end
+        
+        ##
+        # Merges this data-frame with +other+ in terms of the +by+ column(s) (Array or String). Keeps all the rows in the other data frame.
+        # +first_alias+ and +second_alias+ allow to specify the prefix that should be used for the columns not in +by+
+        # for this and the +other+ data-frame, respectively.
+        
+        def right_merge(other, by, first_alias, second_alias, **options)
+            options[:keep_right] = true
+            options[:keep_left]  = false
+            return self.merge(other, by, first_alias, second_alias, **options)
+        end
+        
         ##
         # Merges this data-frame with +other+ in terms of the +by+ column(s) (Array or String).
         # +first_alias+ and +second_alias+ allow to specify the prefix that should be used for the columns not in +by+
         # for this and the +other+ data-frame, respectively.
         
-        def merge(other, by, first_alias = "x", second_alias = "y")
+        def merge(other, by, first_alias = "x", second_alias = "y", **options)
             raise TypeError, "Expected Rust::DataFrame" unless other.is_a?(DataFrame)
             raise TypeError, "Expected list of strings" if !by.is_a?(Array) || !by.all? { |e| e.is_a?(String) }
             raise "This dataset should have all the columns in #{by}" unless (by & self.column_names).size == by.size
             raise "The passed dataset should have all the columns in #{by}" unless (by & other.column_names).size == by.size
+            raise "Either keep_right or keep_left should be provided as options, not both" if options[:keep_right] && options[:keep_left]
             
             if first_alias == second_alias
                 if first_alias == ""
@@ -473,6 +518,28 @@ module Rust
                     end
                     
                     result << to_add
+                    
+                elsif options[:keep_right]
+                    to_add = {}
+                    
+                    by.each do |colname|
+                        to_add[colname] = other_row[colname]
+                    end
+                    
+                    merged_column_self.each do |colname|
+                        to_add["#{first_alias}#{colname}"] = nil
+                    end
+                    
+                    merged_column_other.each do |colname|
+                        to_add["#{second_alias}#{colname}"] = other_row[colname]
+                    end
+                    
+                    result << to_add
+                    
+                elsif options[:keep_left]
+                    options[:keep_left]  = false
+                    options[:keep_right] = true
+                    return other.merge(self, by, first_alias, second_alias, **options)
                 end
             end
             

data/lib/rust/core/types/datatype.rb

@@ -36,7 +36,7 @@ module Rust
             if candidates.size > 0
                 type = candidates.max_by { |c| c.pull_priority }
                 
-                puts "Using #{type} to pull #{variable}" if Rust.debug?
+                puts "Using #{type} to pull #{variable} (candidates: #{candidates.map { |c| c.to_s + "=>" + c.pull_priority.to_s}.join(", ")})" if Rust.debug?
                 return type.pull_variable(variable, r_type, r_class)
             else
                 if Rust._pull("length(#{variable})") == 0
@@ -80,7 +80,7 @@ module Rust
         def r_mirror
             varname = self.mirrored_R_variable_name
                         
-            if !Rust._pull("exists(\"#{varname}\")") || Rust._pull("#{varname}.hash") != self.r_hash
+            if !Rust._pull("exists(\"#{varname}\")") || Rust["#{varname}.hash"] != self.r_hash
                 puts "Loading #{varname}" if Rust.debug?
                 Rust[varname] = self
                 Rust["#{varname}.hash"] = self.r_hash

data/lib/rust/core/types/factor.rb

@@ -125,6 +125,10 @@ module Rust
             @level
         end
         
+        def to_str
+           @level.to_s
+        end
+        
         def to_R
             self.to_i
         end

data/lib/rust/core/types/language.rb

@@ -137,7 +137,7 @@ module Rust
         # Sets the +arguments+ (Arguments type) of the function.
         
         def arguments=(arguments)
-            raise TypeError, "Expected Arguments" unless options.is_a?(Arguments)
+            raise TypeError, "Expected Arguments" unless arguments.is_a?(Arguments)
             
             @arguments = arguments
         end
@@ -171,6 +171,22 @@ module Rust
         end
     end
     
+    ##
+    # Represents a verbatim R expression
+    
+    class Verbatim
+        ## 
+        #Creates a verbatim R expression
+        
+        def initialize(expression)
+            @expression = expression
+        end
+        
+        def to_R
+            @expression
+        end
+    end
+    
     ##
     # Represents the arguments of a function in R. Works as an Array of objects.
     
@@ -196,4 +212,20 @@ module Rust
             return options
         end
     end
+    
+    def self.verbatim(expression)
+        Verbatim.new(expression)
+    end
+    
+    def self.variable(variable)
+        Variable.new(variable)
+    end
+    
+    def self.function(name)
+        Function.new(name)
+    end
+    
+    def self.formula(left_part, right_part)
+        Formula.new(left_part, right_part)
+    end
 end 

data/lib/rust/core/types/list.rb

@@ -29,6 +29,8 @@ module Rust
             @data.each do |key, value|
                 Rust["#{variable_name}[[#{key + 1}]]"] = value
             end
+            
+            Rust._eval("names(#{variable_name}) <- #{self.names.to_R}")
         end
         
         ##

data/lib/rust/core/types/matrix.rb

@@ -81,6 +81,14 @@ module Rust
             @data.size
         end
         
+        def rownames
+            @row_names
+        end
+        
+        def colnames
+            @column_names
+        end
+        
         ##
         # Returns the number of columns.
         

data/lib/rust/core.rb

@@ -1,7 +1,57 @@
 require_relative 'core/rust'
 require_relative 'core/csv'
+require_relative 'core/manual'
 
 self_path = File.expand_path(__FILE__)
 Dir.glob(File.join(File.dirname(self_path), "core/types/*.rb")).each do |lib|
     require_relative lib
 end
+
+Rust::Manual.register(:base, "Quick intro", "Core philosophy behind Rust.")
+Rust::Manual.for(:base).register('Introduction', /intro/,
+<<-EOS
+Rust is a statistical library. Rust wraps R and its libraries to achieve this goal.
+Rust aims at:
+- Making easier for Ruby developers make all the kinds of operations that are straightforward in R;
+- Providing an object-oriented interface, more familiar than the one in R.
+
+Rust can be used in two ways:
+- By using the object-oriented interface (advised if you are writing a script);
+- By using the R bindings, that allow to use Ruby pretty much like R (handful if you are using it from IRB).
+
+Rust provides wrappers for many elements, including types (e.g., data frames), statistical hypothesis tests, plots, and so on.
+Under the hood, Rust creates an R environment (through rinruby), through which Rust can perform the most advanced operations,
+for which a re-implementation would be impractical.
+EOS
+)
+
+Rust::Manual.for(:base).register('Types', /type/,
+<<-EOS
+Rust provides wrappers for the most commonly-found types in R. Specifically, the following types are available:
+- Data frames → Rust::DataFrame
+- Factors → Rust::Factor
+- Matrices → Rust::Matrix
+- Lists → Rust::List
+- S4 classes → Rust::S4Class
+- Formulas → Rust::Formula
+
+Note that some of them (e.g., data frames and matrices) are not just wrappers, but complete re-implementations of the R
+types (for performance reasons).
+EOS
+)
+
+Rust::Manual.for(:base).register('CSVs', /csv/,
+<<-EOS
+Rust allows to read and write CSV files, mostly like in R.
+To read a CSV file, you can use:
+Rust::CSV.read(filename)
+
+It returns a data frame. You can also specify the option "headers" to tell if the first row in the CSV contains the headers 
+(column names for the data frame). Other options get directly passed to the R function "read.csv".
+
+To write a CSV file, you can use:
+Rust::CSV.write(filename, data_frame)
+
+It writes the given data frame on the file at filename.
+EOS
+)

data/lib/rust/external/ggplot2/core.rb

@@ -0,0 +1,171 @@
+require_relative '../../../rust'
+
+Rust.prerequisite("ggplot2")
+
+module Rust::Plots::GGPlot
+    def self.default_theme
+        @@theme
+    end
+    
+    def self.default_theme=(theme)
+        @@theme = theme.freeze
+    end
+    
+    class Layer
+        def initialize(function_name, **options)
+            @function_name = function_name
+            @arguments = Rust::Arguments.new
+            @options = Rust::Options.from_hash(options)
+        end
+        
+        def option(key, value)
+            @options[key] = value
+        end
+        
+        def to_R
+            if !block_given?
+                options, arguments = @options, @arguments
+            else
+                options, arguments = yield(@options, @arguments)
+            end
+            
+            options = Rust::Options.from_hash(options) unless options.is_a?(Rust::Options)
+            
+            function = Rust::Function.new(@function_name)
+            function.arguments = arguments if arguments
+            function.options = options if options
+            return function.to_R
+        end
+    end
+    
+    class Aes
+        def initialize(**options)
+            options = options.map { |k, v| [k, v.is_a?(Symbol) ? Rust::Variable.new(v) : v] }.to_h
+            @options = Rust::Options.from_hash(options)
+        end
+        
+        def to_R
+            function = Rust::Function.new("aes")
+            function.options = @options if @options
+            return function.to_R
+        end
+    end
+    
+    class Plot
+        attr_accessor   :theme
+        attr_accessor   :aes
+        
+        def initialize(data, aes = nil)
+            @layers = []
+            
+            @data = data
+            @aes = aes
+            @theme = Rust::Plots::GGPlot.default_theme
+        end
+        
+        def layer(layer)
+            @layers << layer
+        end
+        
+        def show()
+            Rust.exclusive do
+                dataset_name = nil
+                if @data
+                    dataset_name = "ggplotter.data"
+                    @data.load_in_r_as(dataset_name)
+                end
+                r = self.to_R(dataset_name)
+                Rust._eval(r)
+            end
+        end
+
+        def save(filename, **options)
+            Rust.exclusive do 
+                dataset_name = nil
+                if @data
+                    dataset_name = "ggplotter.data"
+                    @data.load_in_r_as(dataset_name)
+                end
+                r = self.to_R(dataset_name)
+                Rust._eval("ggplot.latest <- #{r}")
+                save = Rust::Function.new("ggsave")
+                save.arguments = Rust::Arguments.new([Rust::Variable.new("ggplot.latest")])
+                save.options = Rust::Options.from_hash({file: filename}.merge(options))
+                save.call
+            end
+        end
+        
+        def to_R(data_set_name="ggplotter.data")
+            function = Rust::Function.new("ggplot")
+            function.arguments = Rust::Arguments.new
+            function.arguments << (data_set_name ? Rust::Variable.new(data_set_name) : nil)
+            function.arguments << @aes if @aes
+            
+            result = function.to_R
+            result += " + " + @theme.to_R
+            @layers.each do |layer|
+                result += " + " + layer.to_R
+            end
+            
+            return result
+        end
+        
+        def <<(others)
+            if others.is_a?(Array) && others.all? { |o| o.is_a?(Layer) }
+                @layers += others
+            elsif others.is_a?(Layer)
+                @layers << others
+            else
+                raise ArgumentError, "Expected Layer or Array of Layers"
+            end
+            
+            return self
+        end
+        
+        def +(others)
+            copy = self.deep_clone
+            copy << others
+            return copy
+        end
+        
+        def inspect(show = true)
+            self.show if show
+            return super()
+        end
+    end
+    
+    class Labels < Layer
+        def initialize(**options)
+            super("labs", **options)
+        end
+    end
+    
+    class FlipCoordinates < Layer
+        def initialize(**options)
+            super("coord_flip", **options)
+        end
+    end
+end
+
+module Rust::RBindings
+    def ggplot(*arguments)
+        Rust::Plots::GGPlot::Plot.new(*arguments)
+    end
+    
+    def aes(**options)
+        Rust::Plots::GGPlot::Aes.new(**options)
+    end
+    
+    def labs(**options)
+        Rust::Plots::GGPlot::Labels.new(**options)
+    end
+    alias :labels :labs
+    
+    def coord_flip(**options)
+        Rust::Plots::GGPlot::FlipCoordinates.new(**options)
+    end
+end
+
+def bind_ggplot!
+    include Rust::Plots::GGPlot
+end