rust 0.12 → 0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8eb6e3759ef38070603a941ef348ac46e4b6c08b4638c493edb2169acf16c793
-  data.tar.gz: f855ca774695688ee64d7513ac94c8b98d3bae154bfae56b803ed1da567cb282
+  metadata.gz: aef18d4ed8bce09d5931fa0e9fde630ff36e1436897a448bbbc1dd2b451a28fc
+  data.tar.gz: 9313ac648a27c9f1cb6b369ba43852e0defb4bd4ab0a089b1c58ad4e43322de5
 SHA512:
-  metadata.gz: c281de698d8b4750832d77971dac857dbee2c31252b7950abf91777d37763bbb79577098ab48efeee6f8a5ef2a28949ef72816d33703eaad14887d588b4aac32
-  data.tar.gz: d44c0532c19ff8eb2f505d4da62e82b4b4f32dada4b39a05cddf57679a3a725dd38ceecf63aaf2d551a8ae691841196bad7cc0694d3613b928a84a9b6291ef6a
+  metadata.gz: 9908bd416aa81bbd07ad8b5f4960481c31e9ed8da2b106e3e129b4165d835343029b43ee0cd1b74b1fd56451039a5558abda553037c4887ebf6f9b5865dc5202
+  data.tar.gz: db41177a2182dc57516459bbfff5ee6d361c275ccd1d78b5a5b2767da433a5cde366303b598d4e9bd00d692c14c682044bbc4976392973415099573185fcee15

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
             
@@ -540,6 +607,8 @@ module Rust
         # Sorts the rows of this data-frame by the values of the +by+ column.
         
         def sort_by!(by)
+            raise TypeError, "String expected" unless by.is_a?(String)
+            raise "'#{by}' is not a valid column name (#{self.colnames.to_s})" unless self.colnames.include?(by)
             copy = @data[by].clone
             copy.sort!
             

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
@@ -109,13 +109,23 @@ module Rust
     
     class Null < RustDatatype
         def self.can_pull?(type, klass)
-            return type == "NULL" && klass == "NULL"
+            return (type == "NULL" && klass == "NULL")
         end
         
         def self.pull_variable(variable, type, klass)
             return nil
         end
     end
+
+    class Omit < RustDatatype
+        def self.can_pull?(type, klass)
+            return (klass == "omit")
+        end
+
+        def self.pull_variable(variable, type, klass)
+            return Rust["as.#{type}(#{variable})"]
+        end
+    end
 end
 
 class TrueClass

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

@@ -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/plot_builder.rb

@@ -64,14 +64,6 @@ module Rust::Plots::GGPlot
             return self
         end
         
-        def labeled(value)
-            raise "No context for assigning a label" unless @current_context
-            @label_options[@current_context] = value
-            @current_context = nil
-            
-            return self
-        end
-        
         def with_x_label(value)
             @label_options[:x] = value
             
@@ -90,6 +82,76 @@ module Rust::Plots::GGPlot
             return self
         end
         
+        def scale_x_continuous(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:x, :continuous, **options)
+            
+            return self
+        end
+        
+        def scale_y_continuous(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:y, :continuous, **options)
+            
+            return self
+        end
+        
+        def scale_x_discrete(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:x, :discrete, **options)
+            
+            return self
+        end
+        
+        def scale_y_discrete(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:y, :discrete, **options)
+            
+            return self
+        end
+        
+        def scale_x_log10(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:x, :log10, **options)
+            
+            return self
+        end
+        
+        def scale_y_log10(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:y, :log10, **options)
+            
+            return self
+        end
+        
+        def scale_x_reverse(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:x, :reverse, **options)
+            
+            return self
+        end
+        
+        def scale_y_reverse(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:y, :reverse, **options)
+            
+            return self
+        end
+        
+        def scale_x_sqrt(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:x, :sqrt, **options)
+            
+            return self
+        end
+        
+        def scale_y_sqrt(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(:y, :sqrt, **options)
+            
+            return self
+        end
+        
         def with_title(value)
             @label_options[:title] = value
             
@@ -160,6 +222,48 @@ module Rust::Plots::GGPlot
             return self
         end
         
+        def labeled(value)
+            raise "No context for assigning a label" unless @current_context
+            @label_options[@current_context] = value
+            
+            return self
+        end
+        
+        def scale_continuous(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(@current_context, :continuous, **options)
+            
+            return self
+        end
+        
+        def scale_discrete(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(@current_context, :discrete, **options)
+            
+            return self
+        end
+        
+        def scale_log10(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(@current_context, :log10, **options)
+            
+            return self
+        end
+        
+        def scale_reverse(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(@current_context, :reverse, **options)
+            
+            return self
+        end
+        
+        def scale_sqrt(**options)
+            raise "No context for assigning a label" unless @current_context
+            @layers << AxisScaler.new(@current_context, :sqrt, **options)
+            
+            return self
+        end
+        
         def flip_coordinates
             @layers << FlipCoordinates.new
             

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

@@ -0,0 +1,12 @@
+require_relative 'core'
+
+module Rust::Plots::GGPlot
+    class AxisScaler < Layer
+        def initialize(axis, type = :continuous, **options)
+            @axis = axis
+            @type = type
+            
+            super("scale_#{@axis}_#{@type}", **options)
+        end
+    end
+end