rust 0.11 → 0.13

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

@@ -0,0 +1,458 @@
+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_", "") if @starting
+            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 ExistingTheme < Layer
+    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)
+            elsif !value
+                return Theme::BlankElement.new
+            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)
+            elsif !value
+                return Theme::BlankElement.new
+            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)
+            elsif !value
+                return Theme::BlankElement.new
+            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 = nil)
+            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
+    
+    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')
+                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,116 @@
+require_relative 'ggplot2/core'
+require_relative 'ggplot2/geoms'
+require_relative 'ggplot2/themes'
+require_relative 'ggplot2/plot_builder'
+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
+)