charty 0.2.0 → 0.2.1

data/lib/charty.rb

@@ -1,8 +1,15 @@
 require_relative "charty/version"
 
+require "colors"
+
 require_relative "charty/backends"
+require_relative "charty/backend_methods"
 require_relative "charty/plotter"
 require_relative "charty/layout"
 require_relative "charty/linspace"
+require_relative "charty/plotters"
+require_relative "charty/plot_methods"
+require_relative "charty/palette"
 require_relative "charty/table_adapters"
 require_relative "charty/table"
+require_relative "charty/statistics"

data/lib/charty/backend_methods.rb

@@ -0,0 +1,8 @@
+module Charty
+  module BackendMethods
+    def use_backend(backend)
+    end
+  end
+
+  extend BackendMethods
+end

data/lib/charty/backends.rb

@@ -6,6 +6,30 @@ module Charty
   module Backends
     @backends = {}
 
+    @current = nil
+
+    def self.current
+      @current
+    end
+
+    def self.current=(backend_name)
+      backend_class = Backends.find_backend_class(backend_name)
+      @current = backend_class.new
+    end
+
+    def self.use(backend)
+      if block_given?
+        begin
+          saved, self.current = self.current, backend
+          yield
+        ensure
+          self.current = saved
+        end
+      else
+        self.current = backend
+      end
+    end
+
     def self.names
       @backends.keys
     end
@@ -48,7 +72,7 @@ module Charty
 end
 
 require "charty/backends/bokeh"
-require "charty/backends/google_chart"
+require "charty/backends/google_charts"
 require "charty/backends/gruff"
 require "charty/backends/plotly"
 require "charty/backends/pyplot"

data/lib/charty/backends/bokeh.rb

@@ -37,42 +37,42 @@ module Charty
         plot.yaxis[0].axis_label = context&.ylabel
 
         case context.method
-          when :bar
-            context.series.each do |data|
-              diffs = data.xs.to_a.each_cons(2).map {|n, m| (n - m).abs }
-              width = diffs.min * 0.8
-              plot.vbar(data.xs.to_a, width, data.ys.to_a)
-            end
+        when :bar
+          context.series.each do |data|
+            diffs = data.xs.to_a.each_cons(2).map {|n, m| (n - m).abs }
+            width = diffs.min * 0.8
+            plot.vbar(data.xs.to_a, width, data.ys.to_a)
+          end
 
-          when :barh
-            context.series.each do |data|
-              diffs = data.xs.to_a.each_cons(2).map {|n, m| (n - m).abs }
-              height = diffs.min * 0.8
-              plot.hbar(data.xs.to_a, height, data.ys.to_a)
-            end
+        when :barh
+          context.series.each do |data|
+            diffs = data.xs.to_a.each_cons(2).map {|n, m| (n - m).abs }
+            height = diffs.min * 0.8
+            plot.hbar(data.xs.to_a, height, data.ys.to_a)
+          end
 
-          when :boxplot
-            raise NotImplementedError
+        when :boxplot
+          raise NotImplementedError
 
-          when :bubble
-            raise NotImplementedError
+        when :bubble
+          raise NotImplementedError
 
-          when :curve
-            context.series.each do |data|
-              plot.line(data.xs.to_a, data.ys.to_a)
-            end
+        when :curve
+          context.series.each do |data|
+            plot.line(data.xs.to_a, data.ys.to_a)
+          end
 
-          when :scatter
-            context.series.each do |data|
-              plot.scatter(data.xs.to_a, data.ys.to_a)
-            end
+        when :scatter
+          context.series.each do |data|
+            plot.scatter(data.xs.to_a, data.ys.to_a)
+          end
 
-          when :error_bar
-            raise NotImplementedError
+        when :error_bar
+          raise NotImplementedError
 
-          when :hist
-            raise NotImplementedError
-          end
+        when :hist
+          raise NotImplementedError
+        end
         plot
       end
     end

data/lib/charty/backends/{google_chart.rb → google_charts.rb}

@@ -1,7 +1,7 @@
 module Charty
   module Backends
-    class GoogleChart
-      Backends.register(:google_chart, self)
+    class GoogleCharts
+      Backends.register(:google_charts, self)
 
       attr_reader :context
 
@@ -70,47 +70,65 @@ module Charty
         def data_column_js
           case context.method
           when :bubble
-            column_js = <<-COLUMN_JS
-              data.addColumn('string', 'ID');
-              data.addColumn('number', 'X');
-              data.addColumn('number', 'Y');
-              data.addColumn('string', 'GROUP');
-              data.addColumn('number', 'SIZE');
-            COLUMN_JS
+            schema = [
+              ["string", "ID"],
+              ["number", "X"],
+              ["number", "Y"],
+              ["string", "GROUP"],
+              ["number", "SIZE"],
+            ]
           when :curve
-            column_js = "data.addColumn('number', '#{context.xlabel}');"
+            schema = []
+            schema << [detect_type(context.series.first.xs), context.xlabel]
             context.series.to_a.each_with_index do |series_data, index|
-              column_js << "data.addColumn('number', '#{series_data.label || index}');"
+              schema << ["number", series_data.label || index]
             end
           else
-            column_js = "data.addColumn('string', '#{context.xlabel}');"
+            schema = ["string", context.xlabel]
             context.series.to_a.each_with_index do |series_data, index|
-              column_js << "data.addColumn('number', '#{series_data.label || index}');"
+              schema << ["number", series_data.label || index]
             end
           end
 
-          column_js
+          columns = schema.collect do |type, label|
+            "data.addColumn(#{type.to_json}, #{label.to_s.to_json});"
+          end
+          columns.join
+        end
+
+        def detect_type(values)
+          case values.first
+          when Time
+            "date"
+          when String
+            "string"
+          else
+            "number"
+          end
         end
 
         def x_labels
-          [].tap do |label|
-            context.series.each do |series|
-              xs_series = if series.xs.detect { |xs_data| xs_data.is_a?(String) }
-                            series.xs.sort_by {|x| format('%10s', "#{x}")}
-                          else
-                            series.xs.sort
-                          end
-              xs_series.each do |xs_data|
-                label << xs_data unless label.any? { |label| label == xs_data }
-              end
+          labels = {}
+          have_string = false
+          context.series.each do |series|
+            series.xs.each do |x|
+              next if labels.key?(x)
+              have_string = true if x.is_a?(String)
+              labels[x] = true
             end
           end
+          if have_string
+            labels.keys.sort_by {|label| "%10s" % x.to_s}
+          else
+            labels.keys.sort
+          end
         end
 
         def data_hash
           {}.tap do |hash|
+            _x_labels = x_labels
             context.series.to_a.each_with_index do |series_data, series_index|
-              x_labels.each do |x_label|
+              _x_labels.each do |x_label|
                 unless hash[x_label]
                   hash[x_label] = []
                 end
@@ -118,14 +136,14 @@ module Charty
                 if data_index = series_data.xs.to_a.index(x_label)
                   hash[x_label] << series_data.ys.to_a[data_index]
                 else
-                  hash[x_label] << "null"
+                  hash[x_label] << nil
                 end
               end
             end
           end
         end
 
-        def formatted_data_array
+        def rows
           case context.method
           when :bubble
             [].tap do |data_array|
@@ -133,10 +151,10 @@ module Charty
                 series_data.xs.to_a.each_with_index do |data, data_index|
                   data_array << [
                     "",
-                    series_data.xs.to_a[data_index] || "null",
-                    series_data.ys.to_a[data_index] || "null",
+                    series_data.xs.to_a[data_index],
+                    series_data.ys.to_a[data_index],
                     series_data[:label] || series_index.to_s,
-                    series_data.zs.to_a[data_index] || "null",
+                    series_data.zs.to_a[data_index],
                   ]
                 end
               end
@@ -150,12 +168,36 @@ module Charty
           else
             [].tap do |data_array|
               data_hash.each do |k, v|
-                data_array << [k.to_s, v].flatten
+                data_array << [k, v].flatten
               end
             end
           end
         end
 
+        def convert_to_javascript(data)
+          case data
+          when Array
+            converted_data = data.collect do |element|
+              convert_to_javascript(element)
+            end
+            "[#{converted_data.join(", ")}]"
+          when Time
+            time = data.dup.utc
+            args = [
+              time.year,
+              time.month - 1,
+              time.day,
+              time.hour,
+              time.min,
+              time.sec,
+              time.nsec / 1000 / 1000,
+            ]
+            "new Date(Date.UTC(#{args.join(", ")}))"
+          else
+            data.to_json
+          end
+        end
+
         def x_range_option
           x_range = if context.method != :barh
                       context&.range&.fetch(:x, nil)
@@ -189,7 +231,7 @@ module Charty
               function drawChart() {
                 const data = new google.visualization.DataTable();
                 #{data_column_js}
-                data.addRows(#{formatted_data_array})
+                data.addRows(#{convert_to_javascript(rows)})
 
                 const view = new google.visualization.DataView(data);
 

data/lib/charty/backends/plotly.rb

@@ -55,24 +55,22 @@ module Charty
         end
       end
 
-      private
-
-      def plotly_load_tag
+      private def plotly_load_tag
         if self.class.with_api_load_tag
           "<script type='text/javascript' src='#{self.class.plotly_src}'></script>"
         else
         end
       end
 
-      def div_id
+      private def div_id
         "charty-plotly-#{self.class.chart_id}"
       end
 
-      def div_style
+      private def div_style
         "width: 100%;height: 100%;"
       end
 
-      def render_graph(context, type, options: {})
+      private def render_graph(context, type, options: {})
         data = context.series.map do |series|
           {
             type: type,
@@ -95,7 +93,7 @@ module Charty
         render_html(data, layout)
       end
 
-      def render_html(data, layout)
+      private def render_html(data, layout)
         <<~FRAGMENT
           #{plotly_load_tag unless self.class.chart_id > 1}
           <div id="#{div_id}" style="#{div_style}"></div>
@@ -104,6 +102,146 @@ module Charty
           </script>
         FRAGMENT
       end
+
+      # ==== NEW PLOTTING API ====
+
+      class HTML
+        def initialize(html)
+          @html = html
+        end
+
+        def to_iruby
+          ["text/html", @html]
+        end
+      end
+
+      def begin_figure
+        @traces = []
+        @layout = {}
+      end
+
+      def bar(bar_pos, values, color: nil, width: 0.8r, align: :center, orient: :v)
+        color = Array(color).map(&:to_hex_string)
+        @traces << {
+          type: :bar,
+          x: bar_pos,
+          y: values,
+          marker: {color: color}
+        }
+        @layout[:showlegend] = false
+      end
+
+      def box_plot(plot_data, positions, color:, gray:,
+                   width: 0.8r, flier_size: 5, whisker: 1.5, notch: false)
+        color = Array(color).map(&:to_hex_string)
+        plot_data.each_with_index do |group_data, i|
+          data = if group_data.empty?
+                   {type: :box, y: [] }
+                 else
+                   {type: :box, y: group_data, marker: {color: color[i]}}
+                 end
+          @traces << data
+        end
+        @layout[:showlegend] = false
+      end
+
+      def set_xlabel(label)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:title] = label
+      end
+
+      def set_ylabel(label)
+        @layout[:yaxis] ||= {}
+        @layout[:yaxis][:title] = label
+      end
+
+      def set_xticks(values)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:tickmode] = "array"
+        @layout[:xaxis][:tickvals] = values
+      end
+
+      def set_xtick_labels(labels)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:tickmode] = "array"
+        @layout[:xaxis][:ticktext] = labels
+      end
+
+      def set_xlim(min, max)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:range] = [min, max]
+      end
+
+      def disable_xaxis_grid
+        # do nothing
+      end
+
+      def show
+        unless defined?(IRuby)
+          raise NotImplementedError,
+                "Plotly backend outside of IRuby is not supported"
+        end
+
+        IRubyOutput.prepare
+
+        html = <<~HTML
+          <div id="%{id}" style="width: 100%%; height:100%%;"></div>
+          <script type="text/javascript">
+            requirejs(["plotly"], function (Plotly) {
+              Plotly.newPlot("%{id}", %{data}, %{layout});
+            });
+          </script>
+        HTML
+
+        html %= {
+          id: SecureRandom.uuid,
+          data: JSON.dump(@traces),
+          layout: JSON.dump(@layout)
+        }
+        IRuby.display(html, mime: "text/html")
+        nil
+      end
+
+      module IRubyOutput
+        @prepared = false
+
+        def self.prepare
+          return if @prepared
+
+          html = <<~HTML
+            <script type="text/javascript">
+              %{win_config}
+              %{mathjax_config}
+              require.config({
+                paths: {
+                  plotly: "https://cdn.plot.ly/plotly-latest.min"
+                }
+              });
+            </script>
+          HTML
+
+          html %= {
+            win_config: window_plotly_config,
+            mathjax_config: mathjax_config
+          }
+
+          IRuby.display(html, mime: "text/html")
+          @prepared = true
+        end
+
+        def self.window_plotly_config
+          <<~END
+            window.PlotlyConfig = {MathJaxConfig: 'local'};
+          END
+        end
+
+
+        def self.mathjax_config
+          <<~END
+            if (window.MathJax) {MathJax.Hub.Config({SVG: {font: "STIX-Web"}});}
+          END
+        end
+      end
     end
   end
 end