rust 0.11 → 0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77dee9cb8c4a1e2894a8054fab8dbf140b8f6a4aed8ef38a60b41564fb5e8e69
-  data.tar.gz: c9bf14d2239f464cf73ffaee86bcbfe9155a323269eff1b34b7bcd1272c46d36
+  metadata.gz: 8eb6e3759ef38070603a941ef348ac46e4b6c08b4638c493edb2169acf16c793
+  data.tar.gz: f855ca774695688ee64d7513ac94c8b98d3bae154bfae56b803ed1da567cb282
 SHA512:
-  metadata.gz: a648f440574e7734f979c0ec5d65bc9594202cfe88414517dcc50482e391360809ced88bbc0b825f548dfd23dd2b9dfe47b71cabbd216249d992d8a18d14717c
-  data.tar.gz: 1b999d94b96c05a0615ff05b3e1588c4a8e822baebba57055ae041a6fe2c7d0355d747e3c88973c9325046c59c4eff013b27336d95297c8c0e1cc06f515b2f27
+  metadata.gz: c281de698d8b4750832d77971dac857dbee2c31252b7950abf91777d37763bbb79577098ab48efeee6f8a5ef2a28949ef72816d33703eaad14887d588b4aac32
+  data.tar.gz: d44c0532c19ff8eb2f505d4da62e82b4b4f32dada4b39a05cddf57679a3a725dd38ceecf63aaf2d551a8ae691841196bad7cc0694d3613b928a84a9b6291ef6a

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

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

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

@@ -0,0 +1,83 @@
+require_relative 'core'
+
+module Rust::Plots::GGPlot
+    class Geom < Layer
+        def initialize(type, arguments = [], **options)
+            super("geom_#{type}", **options)
+            @type = type
+            @arguments = Rust::Arguments.new(arguments)
+        end
+    end
+    
+    class GeomPoint < Geom
+        def initialize(arguments = [], **options)
+            super("point", arguments, **options)
+        end
+    end
+    
+    class GeomLine < Geom
+        def initialize(arguments = [], **options)
+            super("line", arguments, **options)
+        end
+    end
+    
+    class GeomCol < Geom
+        def initialize(arguments = [], **options)
+            super("col", arguments, **options)
+        end
+    end
+    
+    class GeomBoxplot < Geom
+        def initialize(arguments = [], **options)
+            super("boxplot", arguments, **options)
+        end
+    end
+    
+    class GeomBar < Geom
+        def initialize(arguments = [], **options)
+            super("bar", arguments, **options)
+        end
+    end
+    
+    class GeomHistogram < Geom
+        def initialize(arguments = [], **options)
+            super("histogram", arguments, **options)
+        end
+    end
+    
+    class GeomDensity < Geom
+        def initialize(arguments = [], **options)
+            super("density", arguments, **options)
+        end
+    end
+end
+
+module Rust::RBindings
+    def geom_point(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomPoint.new(*arguments, **options)
+    end
+    
+    def geom_line(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomLine.new(*arguments, **options)
+    end
+    
+    def geom_col(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomCol.new(*arguments, **options)
+    end
+    
+    def geom_bar(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomBar.new(*arguments, **options)
+    end
+    
+    def geom_boxplot(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomBoxplot.new(*arguments, **options)
+    end
+    
+    def geom_histogram(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomHistogram.new(*arguments, **options)
+    end
+    
+    def geom_density(*arguments, **options)
+        return Rust::Plots::GGPlot::GeomDensity.new(*arguments, **options)
+    end
+end

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

@@ -0,0 +1,122 @@
+require_relative 'core'
+
+GGPLOT_EXAMPLES = {}
+
+GGPLOT_EXAMPLES[["Quick 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
+
+GGPLOT_EXAMPLES[["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
+
+GGPLOT_EXAMPLES[["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
+
+GGPLOT_EXAMPLES[["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
+
+GGPLOT_EXAMPLES[["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
+
+GGPLOT_EXAMPLES[["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
+
+module Rust::Plots::GGPlot
+    def self.help!(topic = nil)
+        unless topic
+            puts "Topics:"
+            GGPLOT_EXAMPLES.keys.each do |key, matcher|
+                puts "- #{key}"
+            end
+            puts "Call again specifying the topic of interest."
+        else
+            GGPLOT_EXAMPLES.each do |key, value|
+                if topic.match(key[1])
+                    puts "*** #{key[0]} ***"
+                    puts value
+                    return
+                end
+            end
+            
+            puts "Topic not found"
+        end
+    end
+end

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

@@ -0,0 +1,188 @@
+require_relative 'core'
+
+Rust.prerequisite("ggplot2")
+
+module Rust::Plots::GGPlot
+    class PlotBuilder
+        def self.for_dataframe(data_frame)
+            return PlotBuilder.new(data_frame)
+        end
+        
+        def initialize(data=nil)
+            @data = data
+            
+            @aes_options   = {}
+            @label_options = {}
+            
+            @current_context = :title
+            
+            @layers = []
+        end
+        
+        def with_x(variable, label = nil)
+            variable = variable.to_sym if variable.is_a?(String)
+            
+            @aes_options[:x] = variable
+            @current_context = :x
+            
+            return self
+        end
+        
+        def with_y(variable)
+            variable = variable.to_sym if variable.is_a?(String)
+            
+            @aes_options[:y] = variable
+            @current_context = :y
+            
+            return self
+        end
+        
+        def with_group(variable)
+            variable = variable.to_sym if variable.is_a?(String)
+            
+            @aes_options[:group] = variable
+            @current_context = :group
+            
+            return self
+        end
+        
+        def with_color(variable)
+            variable = variable.to_sym if variable.is_a?(String)
+            
+            @aes_options[:color] = variable
+            @current_context = :color
+            
+            return self
+        end
+        
+        def with_fill(variable)
+            variable = variable.to_sym if variable.is_a?(String)
+            
+            @aes_options[:fill] = variable
+            @current_context = :fill
+            
+            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
+            
+            return self
+        end
+        
+        def with_y_label(value)
+            @label_options[:y] = value
+            
+            return self
+        end
+        
+        def with_color_label(value)
+            @label_options[:color] = value
+            
+            return self
+        end
+        
+        def with_title(value)
+            @label_options[:title] = value
+            
+            return self
+        end
+        
+        def draw_points(**options)
+            @layers << GeomPoint.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_lines(**options)
+            @layers << GeomLine.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_bars(**options)
+            @layers << GeomBar.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_cols(**options)
+            @layers << GeomCol.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_boxplot(**options)
+            @layers << GeomBoxplot.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_histogram(**options)
+            @layers << GeomHistogram.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def draw_density(**options)
+            @layers << GeomDensity.new(**options)
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def with_theme(theme)
+            @layers << theme
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def flip_coordinates
+            @layers << FlipCoordinates.new
+            
+            @current_context = nil
+            
+            return self
+        end
+        
+        def build
+            plot = Plot.new(@data, Aes.new(**@aes_options))
+            plot.theme = @theme if @theme
+            plot << @layers if @layers.size > 0
+            if @label_options.size > 0
+                if @label_options.keys.include?(:group)
+                    value = @label_options.delete(:group)
+                    selected = [:x, :y] - @label_options.keys
+                    @label_options[selected.first] = value if selected.size == 1
+                end
+                
+                plot << Labels.new(**@label_options)
+            end
+            
+            return plot
+        end
+    end
+end

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

@@ -0,0 +1,435 @@
+require 'json'
+require_relative 'core'
+
+module Rust::Plots::GGPlot
+    class Theme < Layer
+        def self.from_h(options)            
+            starting = options.delete('_starting')
+            options = options.map do |key, value|
+                if value.is_a?(Hash)
+                    case value.delete('_type').split("::").last
+                    when 'TextElement'
+                        [key, TextElement.new(**value)]
+                    when 'RectElement'
+                        [key, RectElement.new(**value)]
+                    when 'TextElement'
+                        [key, TextElement.new(**value)]
+                    when 'LineElement'
+                        [key, LineElement.new(**value)]
+                    end
+                else
+                    [key, value]
+                end
+            end.to_h
+            
+            return Theme.new(starting, **options)
+        end
+        
+        def self.load(filename)
+            json = JSON.parse(File.read(filename))
+            return self.from_h(json.to_h)
+        end
+        
+        def initialize(starting, **options)
+            super("theme", **options)
+            if starting
+                @starting = "theme_" + starting
+            end
+        end
+        
+        def to_R
+            result = super do |options, arguments| 
+                [
+                    options.map { |k, v| [k.to_s.gsub("_", "."), v] }.to_h,
+                    arguments
+                ] 
+            end
+            
+            result = Rust::Function.new(@starting).to_R + " + " +  result if @starting
+            
+            return result
+        end
+        
+        def to_h
+            options = @options.clone
+            
+            options['_starting'] = @starting.sub("theme_", "")
+            options = options.map do |key, value|
+                [key, value.is_a?(Theme::Element) ? value.to_h : value]
+            end.to_h
+            
+            return options
+        end
+        
+        def save(path, force = false)
+            if !force && FileTest.exist?(path)
+                raise "File already existing."
+            end
+            
+            File.open(path, "w") do |f|
+                f.write(
+                    JSON.pretty_generate(
+                        self.to_h
+                    )
+                )
+            end
+            
+            return true
+        end
+    end
+    
+    class Theme::Element
+        attr_reader :options
+        
+        def initialize(**options)
+            @options = options
+        end
+        
+        def r_function
+            raise "Not implemented for generic theme element"
+        end
+        
+        def to_R
+            options = @options.map { |k, v| [k.to_s.gsub("_", "."), v] }.to_h
+            
+            function = Rust::Function.new(self.r_function)
+            function.options = Rust::Options.from_hash(options)
+            
+            return function.to_R
+        end
+        
+        def to_h
+            hash = @options.clone
+            hash['_type'] = self.class.name
+            return hash
+        end
+    end
+    
+    class Theme::TextElement < Theme::Element
+        def r_function
+            return "element_text"
+        end
+    end
+    
+    class Theme::LineElement < Theme::Element
+        def r_function
+            return "element_line"
+        end
+    end
+    
+    class Theme::RectElement < Theme::Element
+        def r_function
+            return "element_rect"
+        end
+    end
+    
+    class Theme::BlankElement < Theme::Element
+        def r_function
+            return "element_blank"
+        end
+    end
+    
+    class ThemeComponentBuilder
+        def initialize(namespace=nil)
+            @namespace = namespace
+            @options = {}
+        end
+        
+        def option(key, value)
+            key = "#@namespace.#{key}" if @namespace
+            @options[key] = value
+            
+            return self
+        end
+        
+        def [](key)
+            key = "#@namespace.#{key}" if @namespace
+            return @options[key]
+        end
+        
+        def line_el(value)
+            if value.is_a?(Theme::LineElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::LineElement.new(**value)
+            else
+                raise "Expected line or hash"
+            end
+        end
+        
+        def rect_el(value)
+            if value.is_a?(Theme::RectElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::RectElement.new(**value)
+            else
+                raise "Expected rect or hash"
+            end
+        end
+        
+        def text_el(value)
+            if value.is_a?(Theme::TextElement) || value.is_a?(Theme::BlankElement)
+                return value
+            elsif value.is_a?(Hash)
+                return Theme::TextElement.new(**value)
+            else
+                raise "Expected text or hash"
+            end
+        end
+        
+        def unit_el(value)
+            numeric = nil
+            unit = nil
+            
+            if input.is_a?(String)
+                numeric, unit = *input.scan(/^([0-9.]+)([A-Za-z]+)/).flatten
+                
+                raise "Unclear numeric part in #{input}" unless numeric
+                raise "Unclear unit part in #{input}"    unless unit
+            elsif input.is_a?(Numeric)
+                numeric = input
+                unit = "npc"
+            end
+            
+            raise "Unable to handle #{input}" unless numeric && unit
+            
+            function = Rust::Function.new("units")
+            function.arguments = Rust::Arguments.new([numeric, unit])
+            
+            return function.to_R
+        end
+        
+        def alignment_el(value)
+            if value.is_a?(String) || value.is_a?(Symbol)
+                case value.to_s.downcase
+                when 'left'
+                    value = 1
+                when 'right'
+                    value = 0
+                else
+                    value = 1
+                end
+            end
+            
+            return value
+        end
+        
+        def numeric_el(value)
+            raise "Expected number" unless value.is_a?(Numeric)
+            return value
+        end
+        
+        def build
+            @options
+        end
+    end
+    
+    class ThemeBuilder < ThemeComponentBuilder
+        def initialize(starting = 'bw')
+            super("plot")
+            @starting = starting
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def axis
+            builder = ThemeAxisBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def legend
+            builder = ThemeLegendBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def panel
+            builder = ThemePanelBuilder.new
+            yield builder
+            
+            @options.merge!(builder.build)
+            return self
+        end
+        
+        def build
+            return Theme.new(@starting, **@options)
+        end
+    end
+    
+    class ThemeAxisBuilder < ThemeComponentBuilder
+        def initialize
+            super("axis")
+        end
+        
+        def line(value)
+            self.option('line', line_el(value))
+        end
+        
+        def text(value)
+            self.option('text', text_el(value))
+        end
+        
+        def text_x(value)
+            self.option('text.x', text_el(value))
+        end
+        
+        def text_y(value)
+            self.option('text.y', text_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def title_x(value)
+            self.option('title.x', text_el(value))
+        end
+        
+        def title_y(value)
+            self.option('title.y', text_el(value))
+        end
+        
+        def ticks(value)
+            self.option('ticks', line_el(value))
+        end
+        
+        def ticks_length(value)
+            self.option('ticks.length', unit_el(value))
+        end
+    end
+    
+    class ThemeLegendBuilder < ThemeComponentBuilder
+        def initialize
+            super("legend")
+        end
+        
+        def position(value)
+            self.option('position', value)
+        end
+        
+        def justification(value)
+            self.option('justification', value)
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def key_background(value)
+            self.option('key', rect_el(value))
+        end
+        
+        def key_size(value)
+            self.option('key.size', unit_el(value))
+        end
+        
+        def key_height(value)
+            self.option('key.height', unit_el(value))
+        end
+        
+        def key_width(value)
+            self.option('key.width', unit_el(value))
+        end
+        
+        def margin(value)
+            self.option('margin', unit_el(value))
+        end
+        
+        def text(value)
+            self.option('text', text_el(value))
+        end
+        
+        def text_align(value)
+            self.option('text.align', alignment_el(value))
+        end
+        
+        def title(value)
+            self.option('title', text_el(value))
+        end
+        
+        def title_align(value)
+            self.option('key.size', alignment_el(value))
+        end
+    end
+    
+    class ThemePanelBuilder < ThemeComponentBuilder
+        def initialize
+            super("panel")
+        end
+        
+        def background(value)
+            self.option('background', rect_el(value))
+        end
+        
+        def border(value)
+            self.option('border', rect_el(value))
+        end
+        
+        def grid_major(value)
+            self.option('grid.major', line_el(value))
+        end
+        
+        def grid_major_x(value)
+            self.option('grid.major.x', line_el(value))
+        end
+        
+        def grid_major_y(value)
+            self.option('grid.major.y', line_el(value))
+        end
+        
+        def grid_minor(value)
+            self.option('grid.minor', line_el(value))
+        end
+        
+        def grid_minor_x(value)
+            self.option('grid.minor.x', line_el(value))
+        end
+        
+        def grid_minor_y(value)
+            self.option('grid.minor.y', line_el(value))
+        end
+        
+        def aspect_ratio(value)
+            self.option('aspect.ratio', numeric_el(value))
+        end
+        
+        def margin(value)
+            self.option('margin', unit_el(value))
+        end
+        
+        def margin_x(value)
+            self.option('margin.x', unit_el(value))
+        end
+        
+        def margin_y(value)
+            self.option('margin.y', unit_el(value))
+        end
+    end
+    
+    self.default_theme = ThemeBuilder.new.
+            title(face: 'bold', size: 12).
+            legend do |legend|
+                legend.background(fill: 'white', size: 4, colour: 'white')
+                legend.position([0, 1])
+                legend.justification([0, 1])
+            end.
+            axis do |axis| 
+                axis.ticks(colour: 'grey70', size: 0.2)
+            end.
+            panel do |panel|
+                panel.grid_major(colour: 'grey70', size: 0.2)
+                panel.grid_minor(Theme::BlankElement.new)
+            end.
+            build
+end

data/lib/rust/external/ggplot2.rb

@@ -0,0 +1,5 @@
+require_relative 'ggplot2/core'
+require_relative 'ggplot2/geoms'
+require_relative 'ggplot2/themes'
+require_relative 'ggplot2/plot_builder'
+require_relative 'ggplot2/helper'

data/lib/rust.rb

@@ -2,3 +2,22 @@ require_relative 'rust/core'
 require_relative 'rust/models/all'
 require_relative 'rust/plots/all'
 require_relative 'rust/stats/all'
+
+module Rust
+    @@datasets = {}
+    
+    def self.toothgrowth
+        @@datasets[:ToothGrowth] = Rust.exclusive { Rust['ToothGrowth'] } unless @@datasets[:ToothGrowth]
+        return @@datasets[:ToothGrowth]
+    end
+    
+    def self.cars
+        @@datasets[:cars] = Rust.exclusive { Rust['cars'] } unless @@datasets[:cars]
+        return @@datasets[:cars]
+    end
+    
+    def self.iris
+        @@datasets[:iris] = Rust.exclusive { Rust['iris'] } unless @@datasets[:iris]
+        return @@datasets[:iris]
+    end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rust
 version: !ruby/object:Gem::Version
-  version: '0.11'
+  version: '0.12'
 platform: ruby
 authors:
 - Simone Scalabrino
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-08-11 00:00:00.000000000 Z
+date: 2022-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rinruby
@@ -71,6 +71,12 @@ files:
 - lib/rust/core/types/matrix.rb
 - lib/rust/core/types/s4class.rb
 - lib/rust/core/types/utils.rb
+- lib/rust/external/ggplot2.rb
+- lib/rust/external/ggplot2/core.rb
+- lib/rust/external/ggplot2/geoms.rb
+- lib/rust/external/ggplot2/helper.rb
+- lib/rust/external/ggplot2/plot_builder.rb
+- lib/rust/external/ggplot2/themes.rb
 - lib/rust/external/robustbase.rb
 - lib/rust/models/all.rb
 - lib/rust/models/anova.rb