rust 0.12 → 0.15

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

@@ -53,7 +53,7 @@ module Rust::Plots::GGPlot
         def to_h
             options = @options.clone
             
-            options['_starting'] = @starting.sub("theme_", "")
+            options['_starting'] = @starting.sub("theme_", "") if @starting
             options = options.map do |key, value|
                 [key, value.is_a?(Theme::Element) ? value.to_h : value]
             end.to_h
@@ -78,6 +78,9 @@ module Rust::Plots::GGPlot
         end
     end
     
+    class ExistingTheme < Layer
+    end
+    
     class Theme::Element
         attr_reader :options
         
@@ -152,6 +155,8 @@ module Rust::Plots::GGPlot
                 return value
             elsif value.is_a?(Hash)
                 return Theme::LineElement.new(**value)
+            elsif !value
+                return Theme::BlankElement.new
             else
                 raise "Expected line or hash"
             end
@@ -162,6 +167,8 @@ module Rust::Plots::GGPlot
                 return value
             elsif value.is_a?(Hash)
                 return Theme::RectElement.new(**value)
+            elsif !value
+                return Theme::BlankElement.new
             else
                 raise "Expected rect or hash"
             end
@@ -172,6 +179,8 @@ module Rust::Plots::GGPlot
                 return value
             elsif value.is_a?(Hash)
                 return Theme::TextElement.new(**value)
+            elsif !value
+                return Theme::BlankElement.new
             else
                 raise "Expected text or hash"
             end
@@ -225,7 +234,7 @@ module Rust::Plots::GGPlot
     end
     
     class ThemeBuilder < ThemeComponentBuilder
-        def initialize(starting = 'bw')
+        def initialize(starting = nil)
             super("plot")
             @starting = starting
         end
@@ -417,7 +426,21 @@ module Rust::Plots::GGPlot
         end
     end
     
-    self.default_theme = ThemeBuilder.new.
+    class ThemeCollection
+        def self.ggtech(name = "google")
+            Rust.prerequisite("ricardo-bion/ggtech", true)
+            
+            return ExistingTheme.new("theme_tech", theme: name)
+        end
+        
+        def self.ggdark(style = "classic")
+            Rust.prerequisite("ggdark")
+            
+            return ExistingTheme.new("dark_theme_#{style}")
+        end
+    end
+    
+    self.default_theme = ThemeBuilder.new("bw").
             title(face: 'bold', size: 12).
             legend do |legend|
                 legend.background(fill: 'white', size: 4, colour: 'white')

data/lib/rust/external/ggplot2.rb

@@ -2,4 +2,115 @@ require_relative 'ggplot2/core'
 require_relative 'ggplot2/geoms'
 require_relative 'ggplot2/themes'
 require_relative 'ggplot2/plot_builder'
-require_relative 'ggplot2/helper'
+require_relative 'ggplot2/scale'
+
+Rust::Manual.register(:ggplot2, "ggplot2", "Informations on the wrapper of the popular ggplot2 plotting library for R.")
+
+Rust::Manual.for(:ggplot2).register("Introduction", /intro/,
+<<-EOS
+bind_ggplot! # Avoid using long module names to reach Rust::Plots::GGPlot (simply includes this module)
+
+# Best with a dataframe, but not necessary. If you have it...
+df = Rust.toothgrowth
+plot = PlotBuilder.for_dataframe(df). # Use a dataframe (symbols will be variable names)
+        labeled("Example plot"). # "labeled" sets the label to the last set aesthetic item (x, y, or title, in this case)
+        with_x(:len).labeled("X data from df").  # Set all the aesthetics (x, y, ...)
+        with_y(:dose).labeled("Y data from df").
+        draw_points. # Set the geometries to plot (based on the plot type)
+        build # Returns the plot ready to use
+plot.show # Show the plot in a window
+plot.save("output.pdf", width: 5, height: 4) # Save the plot, width, height etc. are optional
+
+# If you don't have a dataframe...
+plot2 = PlotBuilder.new.
+        with_x([1,2,3]).labeled("X data from df").
+        with_y([3,4,5]).labeled("Y data from df").
+        draw_points.
+        build
+plot2.show
+EOS
+)
+
+Rust::Manual.for(:ggplot2).register("Scatter plots", /scatter/,
+<<-EOS
+bind_ggplot!
+df = Rust.toothgrowth
+plot = PlotBuilder.for_dataframe(df).
+        with_x(:len).labeled("X data").
+        with_y(:dose).labeled("Y data").
+        draw_points. # To draw points
+        draw_lines.  # To draw lines (keep both to draw both)
+        build
+plot.show
+EOS
+)
+
+Rust::Manual.for(:ggplot2).register("Bar plots", /bar/,
+<<-EOS
+bind_ggplot!
+df = Rust.toothgrowth
+plot = PlotBuilder.for_dataframe(df).
+        with_x(:len).labeled("X data").
+        with_fill(:supp).labeled("Legend"). # Use with_fill or with_color for stacked plots
+        draw_bars. # To draw bars
+        build
+plot.show
+EOS
+)
+
+Rust::Manual.for(:ggplot2).register("Box plots", /box/,
+<<-EOS
+bind_ggplot!
+df = Rust.toothgrowth
+plot = PlotBuilder.for_dataframe(df).
+        with_y(:len).labeled("Data to boxplot").
+        with_group(:supp).labeled("Groups"). # Groups to plot
+        draw_boxplot.
+        build
+plot.show
+EOS
+)
+
+Rust::Manual.for(:ggplot2).register("Histograms", /hist/,
+<<-EOS
+bind_ggplot!
+df = Rust.toothgrowth
+plot = PlotBuilder.for_dataframe(df).
+        with_x(:len).labeled("Data to plot").
+        with_fill(:supp).labeled("Color"). # Use with_fill or with_color for multiple plots
+        draw_histogram.
+        build
+plot.show
+EOS
+)
+
+Rust::Manual.for(:ggplot2).register("Themes", /them/,
+<<-EOS
+bind_ggplot!
+df = Rust.toothgrowth
+# The method with_theme allows to change theme options. The method can be called
+# several times, each time the argument does not overwrite the previous options,
+# unless they are specified again (in that case, the last specified ones win).
+plot = PlotBuilder.for_dataframe(df).
+        with_x(:len).labeled("X data").
+        with_y(:dose).labeled("Y data").
+        draw_points.
+        with_theme(
+            ThemeBuilder.new('bw').
+                title(face: 'bold', size: 12). # Each method sets the property for the related element
+                legend do |legend| # Legend and other parts can be set like this
+                    legend.position(:left) # Puts the legend on the left
+                end.
+                axis do |axis| # Modifies the axes
+                    axis.line(Theme::BlankElement.new) # Hides the lines for the axes
+                    axis.text_x(size: 3) # X axis labels
+                end.
+                panel do |panel|
+                    panel.grid_major(colour: 'grey70', size: 0.2) # Sets the major ticks grid
+                    panel.grid_minor(Theme::BlankElement.new) # Hides the minor ticks grid
+                end.
+                build
+        ).build
+plot.show
+EOS
+)

data/lib/rust/forms/all.rb

@@ -0,0 +1,4 @@
+self_path = File.expand_path(__FILE__)
+Dir.glob(File.dirname(self_path) + "/*.rb").each do |lib|
+    require_relative lib unless lib == self_path
+end

data/lib/rust/forms/google_forms.rb

@@ -0,0 +1,283 @@
+require_relative '../core'
+require 'time'
+
+module Rust
+    
+    ##
+    # Class that allows to read CSVs exported from Google Forms.
+    class GoogleFormMapping
+
+        ##
+        # Loads a mapping from a CSV file that can be used in the constructor of GoogleForm given the CSV +filename+ and the
+        # keys for defining what should be transformed (+key_from+) in what (+key_to+). Returns a hash with the mapping
+        # from -> to.
+
+        def self.load(filename, key_from="from", key_to="to", **options)
+            raise TypeError, "Expected string for filename" unless filename.is_a?(String)
+            raise TypeError, "Expected string for key_from" unless key_from.is_a?(String)
+            raise TypeError, "Expected string for key_to" unless key_to.is_a?(String)
+
+            result = {}
+            mapping = Rust::CSV.read(filename, headers: true)
+            mapping.each do |r|
+                result[r[key_from]] = r[key_to]
+            end
+
+            return GoogleFormMapping.new(result, **options)
+        end
+
+        def initialize(hash, **options)
+            raise TypeError, "Hash should be an hash" unless hash.is_a?(Hash)
+            raise TypeError, "Mapping for question #{question} must have either all String keys or all Regexp keys." if !hash.keys.all? { |m| m.is_a?(Regexp) } && !hash.keys.all? { |m| m.is_a?(String) }
+            raise "Unsupported options: #{options.keys - [:strip, :downcase]}" if (options.keys - [:strip, :downcase]).size > 0
+
+            if hash.keys.all? { |m| m.is_a?(Regexp) }
+                @type = :regexp
+            else
+                @type = :direct
+            end
+
+            @strip = options[:strip]
+            @downcase = options[:downcase]
+
+            if @type == :direct
+                @hash = {}
+                hash.each do |k, v|
+                    @hash[normalize(k)] = v
+                end
+            else
+                @hash = hash
+            end
+        end
+
+        def get(from)
+            if @type == :regexp
+                @hash.each do |k, v|
+                    if from.match(k)
+                        return v
+                    end
+                end
+                return from
+            elsif @type == :direct
+                return @hash[normalize(from)] || from
+            end
+        end
+
+        private
+        def normalize(string)
+            string = string.downcase if @downcase
+            string = string.strip    if @strip
+            return string
+        end
+    end
+    
+    class GoogleForm
+        ALLOWED_TYPES = [:multiple, :checkbox, :scale, :text]
+
+        ##
+        # Reads the CSV at +filename+ and returns a GoogleForm. The schema must be a hash that contains, for each question number or name,
+        # the type of answer (:multiple, :checkbox, :scale, or :text). For the other options, see Rust::CSV.read.
+        
+        def self.read(filename, schema, mappings={}, **options)
+            data_frame = Rust::CSV.read(filename, **options)
+
+            return GoogleForm.new(data_frame, schema, mappings)
+        end
+        
+        def initialize(data_frame, schema, mappings={})
+            raise TypeError, "Expected Rust::DataFrame" unless data_frame.is_a?(Rust::DataFrame)
+            raise TypeError, "Expected Hash or Array" if !schema.is_a?(Hash) && !schema.is_a?(Array)
+            raise TypeError, "Schema keys must all be numbers or strings" if schema.is_a?(Hash) && !schema.keys.all? { |k| k.is_a?(String) }
+            raise TypeError, "Mappings should be an hash [String, Integer] -> GoogleFormMapping" if !mappings.is_a?(Hash) || !mappings.keys.all? { |k| k.is_a?(String) || k.is_a?(Integer) } || !mappings.values.all? { |v| v.is_a?(GoogleFormMapping) }
+            if schema.is_a?(Array)
+                new_schema = {}
+                for i in 0...schema.size
+                    new_schema[index_to_title(i+1, data_frame)] = schema[i]
+                end
+                schema = new_schema
+            end
+            raise TypeError, "Schema values must all be #{ALLOWED_TYPES}; #{schema.values.uniq - ALLOWED_TYPES} given instead" if !schema.values.all? { |v| ALLOWED_TYPES.include?(v)}
+            raise TypeError, "Schema must include types for all the questions" if schema.size != (data_frame.columns - 1)
+
+            @data_frame = data_frame
+            @questions  = data_frame.colnames
+            @schema = schema
+
+            mappings.each do |question, mapping|
+                raise "Mappings can not be defined for :scale questions" if schema[title_to_index(question)] == :scale
+            end
+            @mappings = mappings
+        end
+
+        def data_frame
+            @data_frame
+        end
+
+        def mapped_data_frame
+            df = Rust::DataFrame.new(@data_frame.colnames)
+            self.each_answer do |a|
+                df << a
+            end
+            return df
+        end
+
+        def rows
+            @data_frame.rows
+        end
+
+        def answer(i)
+            row = @data_frame.row(i)
+
+            @questions.each_with_index do |colname, i|
+                if i == 0
+                    row[colname] = Time.parse(row[colname])
+                else
+                    row[colname] = get_value(row[colname], colname)
+                end
+            end
+
+            return row
+        end
+
+        def each_answer
+            for i in 0...@data_frame.rows
+                yield(self.answer(i))
+            end
+        end
+
+        def answers
+            answers = []
+            for i in 0...@data_frame.rows
+                answers << self.answer(i)
+            end
+            return answers
+        end
+
+        def filter
+            matching = Rust::DataFrame.new(@questions)
+
+            for i in 0...@data_frame.rows
+                matching << @data_frame.row(i) if yield(self.answer(i))
+            end
+
+            return GoogleForm.new(matching, @schema, @mappings)
+        end
+
+        def raw_answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+            results = []
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                results << value
+            end
+
+            return results
+        end
+
+        def answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+
+            results = {}
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                if value.is_a?(Array)
+                    value.each do |v|
+                        results[v] = 0 unless results[v]
+                        results[v] += 1
+                    end
+                else
+                    results[value] = 0 unless results[value]
+                    results[value] += 1
+                end
+            end
+            results.delete(nil)
+
+            return results
+        end
+
+        def textual_answers_to(question)
+            question = index_to_title(question) if question.is_a?(Integer)
+            raise TypeError, "Expected textual question, #{@schema[question]} instead" if @schema[question] != :text
+
+            results = {}
+
+            (@data_frame|question).each do |value|
+                value = get_value(value, question)
+                next if value == nil
+
+                category = yield(value)
+                results[category] = 0 unless results[category]
+                results[category] += 1
+            end
+
+            return results
+        end
+
+        def percentual_answers_to(question, exclude=[])
+            answers = answers_to(question)
+
+            exclude.each do |ex|
+                answers.delete(ex)
+            end
+
+            tot = answers.values.sum
+            answers = answers.map { |k, v| [k, v.to_f/tot] }.to_h
+            return answers
+        end
+
+        def percentual_textual_answers_to(question, &block)
+            answers = textual_answers_to(question, &block)
+
+            tot = answers.values.sum
+            answers = answers.map { |k, v| [k, v.to_f/tot] }.to_h
+            return answers
+        end
+
+        private
+        def index_to_title(i, data_frame=@data_frame)
+            data_frame.colnames[i]
+        end
+
+        def title_to_index(title, data_frame=@data_frame)
+            data_frame.colnames.index(title)
+        end
+
+        def get_value(value, question, data_frame=@data_frame)
+            mapping = @mappings[question]
+
+            mapped_value = mapping ? mapping.get(value) : value
+
+            case @schema[question]
+            when :multiple
+                return nil if mapped_value == ""
+                return mapped_value
+
+            when :checkbox
+                return value.split(';').map { |single_value| mapping ? mapping.get(single_value) : single_value }
+
+            when :scale
+                return nil if value == ""
+                ordinal = (data_frame|question).uniq.sort
+                ordinal.delete("")
+                return ordinal.index(value) + 1
+
+            when :text
+                return mapped_value
+            end
+
+            raise TypeError
+        end
+    end
+end
+
+module Rust::RBindings
+    def read_csv(filename, **options)
+        Rust::CSV.read(filename, **options)
+    end
+    
+    def write_csv(filename, dataframe, **options)
+        Rust::CSV.write(filename, dataframe, **options)
+    end
+end

data/lib/rust/jobs/all.rb

@@ -0,0 +1,4 @@
+self_path = File.expand_path(__FILE__)
+Dir.glob(File.dirname(self_path) + "/*.rb").each do |lib|
+    require_relative lib unless lib == self_path
+end

data/lib/rust/jobs/jobs.rb

@@ -0,0 +1,144 @@
+require_relative '../core'
+
+module Rust::Jobs
+    class TaskHook
+        def initialize(task, on_complete, on_error)
+            @task = task
+            @on_complete = on_complete
+            @on_error = on_error
+        end
+
+        def complete!
+            @on_complete.call
+            @task.notify
+        end
+
+        def error!
+            @on_error.call
+            @task.notify
+        end
+    end
+
+    class Task
+        def initialize(title, &block)
+            raise "Expected block to describe the task" unless block_given?
+            @title = title
+            @todo  = block
+            @done  = false
+
+            @complete_hook = proc {}
+            @error_hook = proc {}
+        end
+
+        def start
+            @thread = Thread.start do
+                @todo.call(TaskHook.new(@complete_hook, @error_hook))
+            end
+        end
+
+        def notify
+            @done = true
+        end
+
+        def waitfor(granularity=0.1)
+            while !@done
+                sleep granularity
+            end
+        end
+
+        def commit
+        end
+
+        def on_complete(&block)
+            raise "Block expected" unless block_given?
+            @complete_hook = block
+        end
+
+        def on_error(&block)
+            raise "Block expected" unless block_given?
+            @error_hook = block
+        end
+    end
+
+    class Job
+        def initialize(name, **options)
+            @name = name
+            @tasks = []
+
+            @parallel = false
+
+            if options['parallel']
+                @parallel = true
+                @parallel_tasks = 10
+            end
+
+            if options['parallel_tasks'].is_a?(Integer)
+                @parallel_tasks = options['parallel_tasks'].to_i
+            end
+
+            @logger = options['logger'] ? options['logger'] : STDOUT
+
+            if options[:quiet]
+                @logger = File.open(File::NULL, "w")
+            end
+        end
+
+        def log(message, type="INFO")
+            @logger << "[#{type}] #{Time.now}: #{message.gsub("\n", " -- ")}"
+        end
+
+        def log_info(message)
+            log(message, "INFO")
+        end
+
+        def log_warning(message)
+            log(message, "WARNING")
+        end
+
+        def log_error(message)
+            log(message, "ERROR")
+        end
+
+        def add_task(task=nil, **options, &block)
+            if block_given?
+                raise "You gave both a block and a task. Please, choose one" if task
+                task = Task.new(options['title'], block)
+            end
+
+            raise "Expected a task, #{task.class} given instead" unless task.is_a?(Task)
+
+            @tasks << task
+        end
+
+        def start
+            log_info "Job \"#@name\" started"
+            if @parallel
+            else
+                @tasks.each do |t|
+                    t.on_complete do
+                        log_info "Task \"#{t.title}\" completed"
+                    end
+
+                    t.on_error do |message|
+                        log_error "Task \"#{t.title}\" did not complete: #{message}"
+                    end
+
+                    log_info "Task \"#{t.title}\" started"
+                    t.start
+                    t.waitfor
+                end
+            end
+        end
+    end
+
+    class Resumeable < Job
+        def initialize(name, **options)
+            super
+            # TODO complete here
+        end
+
+        def start
+            # TODO complete here
+        end
+    end
+end