charty 0.1.5.dev → 0.2.0

data/lib/charty.rb

@@ -1,7 +1,8 @@
 require_relative "charty/version"
 
+require_relative "charty/backends"
 require_relative "charty/plotter"
-require_relative "charty/plotter_adapter"
 require_relative "charty/layout"
 require_relative "charty/linspace"
+require_relative "charty/table_adapters"
 require_relative "charty/table"

data/lib/charty/backends.rb

@@ -0,0 +1,55 @@
+module Charty
+  class BackendError < RuntimeError; end
+  class BackendNotFoundError < BackendError; end
+  class BackendLoadError < BackendError; end
+
+  module Backends
+    @backends = {}
+
+    def self.names
+      @backends.keys
+    end
+
+    def self.register(name, backend_class)
+      @backends[normalize_name(name)] = {
+        class: backend_class,
+        prepared: false,
+      }
+    end
+
+    def self.find_backend_class(name)
+      backend = @backends[normalize_name(name)]
+      unless backend
+        raise BackendNotFoundError, "Backend is not found: #{name.inspect}"
+      end
+      backend_class = backend[:class]
+      unless backend[:prepared]
+        if backend_class.respond_to?(:prepare)
+          begin
+            backend_class.prepare
+          rescue LoadError
+            raise BackendLoadError, "Backend load error: #{name.inspect}"
+          end
+        end
+        backend[:prepared] = true
+      end
+      backend_class
+    end
+
+    private_class_method def self.normalize_name(name)
+      case name
+      when Symbol
+        name.to_s
+      else
+        name.to_str
+      end
+    end
+  end
+end
+
+require "charty/backends/bokeh"
+require "charty/backends/google_chart"
+require "charty/backends/gruff"
+require "charty/backends/plotly"
+require "charty/backends/pyplot"
+require "charty/backends/rubyplot"

data/lib/charty/backends/bokeh.rb

@@ -1,74 +1,80 @@
-require 'pycall'
-
 module Charty
-  class Bokeh < PlotterAdapter
-    Name = "bokeh"
+  module Backends
+    class Bokeh
+      Backends.register(:bokeh, self)
 
-    def initialize
-      @plot = PyCall.import_module('bokeh.plotting')
-    end
+      class << self
+        def prepare
+          require 'pycall'
+        end
+      end
 
-    def series=(series)
-      @series = series
-    end
+      def initialize
+        @plot = PyCall.import_module('bokeh.plotting')
+      end
 
-    def render(context, filename)
-      plot = plot(context)
-      save(plot, context, filename)
-      PyCall.import_module('bokeh.io').show(plot)
-    end
+      def series=(series)
+        @series = series
+      end
 
-    def save(plot, context, filename)
-      if filename
-        PyCall.import_module('bokeh.io').save(plot, filename)
+      def render(context, filename)
+        plot = plot(context)
+        save(plot, context, filename)
+        PyCall.import_module('bokeh.io').show(plot)
       end
-    end
 
-    def plot(context)
-      #TODO To implement boxplot, bublle, error_bar, hist.
+      def save(plot, context, filename)
+        if filename
+          PyCall.import_module('bokeh.io').save(plot, filename)
+        end
+      end
 
-      plot = @plot.figure(title: context&.title)
-      plot.xaxis[0].axis_label = context&.xlabel
-      plot.yaxis[0].axis_label = context&.ylabel
+      def plot(context)
+        #TODO To implement boxplot, bublle, error_bar, hist.
 
-      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
+        plot = @plot.figure(title: context&.title)
+        plot.xaxis[0].axis_label = context&.xlabel
+        plot.yaxis[0].axis_label = context&.ylabel
 
-        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
+        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 :boxplot
-          raise NotImplementedError
+          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 :bubble
-          raise NotImplementedError
+          when :boxplot
+            raise NotImplementedError
 
-        when :curve
-          context.series.each do |data|
-            plot.line(data.xs.to_a, data.ys.to_a)
-          end
+          when :bubble
+            raise NotImplementedError
 
-        when :scatter
-          context.series.each do |data|
-            plot.scatter(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 :error_bar
-          raise NotImplementedError
+          when :scatter
+            context.series.each do |data|
+              plot.scatter(data.xs.to_a, data.ys.to_a)
+            end
 
-        when :hist
-          raise NotImplementedError
-        end
-      plot
+          when :error_bar
+            raise NotImplementedError
+
+          when :hist
+            raise NotImplementedError
+          end
+        plot
+      end
     end
   end
 end

data/lib/charty/backends/google_chart.rb

@@ -1,167 +1,225 @@
 module Charty
-  class GoogleChart < PlotterAdapter
-    Name = "google_chart"
-    attr_reader :context
+  module Backends
+    class GoogleChart
+      Backends.register(:google_chart, self)
 
-    def self.chart_id=(chart_id)
-      @chart_id = chart_id
-    end
+      attr_reader :context
 
-    def self.chart_id
-      @chart_id ||= 0
-    end
+      class << self
+        attr_writer :chart_id, :google_charts_src, :with_api_load_tag
 
-    def initilize
-    end
+        def chart_id
+          @chart_id ||= 0
+        end
 
-    def label(x, y)
-    end
+        def with_api_load_tag
+          return @with_api_load_tag unless @with_api_load_tag.nil?
 
-    def series=(series)
-      @series = series
-    end
+          @with_api_load_tag = true
+        end
 
-    def render(context, filename)
-      plot(nil, context)
-    end
+        def google_charts_src
+          @google_charts_src ||= 'https://www.gstatic.com/charts/loader.js'
+        end
+      end
 
-    def plot(plot, context)
-      @context = context
-      self.class.chart_id = self.class.chart_id + 1
-
-      case context.method
-      when :bar
-        generate_render_js("BarChart")
-      when :scatter
-        generate_render_js("ScatterChart")
-      when :bubble
-        generate_render_js("BubbleChart")
-      else
-        raise NotImplementedError
+      def initilize
+      end
+
+      def label(x, y)
       end
-    end
 
-    private
+      def series=(series)
+        @series = series
+      end
 
-      def google_chart_load_tag
-        "<script type='text/javascript' src='https://www.gstatic.com/charts/loader.js'></script>"
+      def render(context, filename)
+        plot(nil, context)
       end
 
-      def headers
-        [].tap do |header|
-          header << context.xlabel
-          context.series.to_a.each_with_index do |series_data, index|
-            header << series_data.label || index
-          end
+      def plot(plot, context)
+        @context = context
+        self.class.chart_id = self.class.chart_id + 1
+
+        case context.method
+        when :bar
+          generate_render_js("ColumnChart")
+        when :barh
+          generate_render_js("BarChart")
+        when :scatter
+          generate_render_js("ScatterChart")
+        when :bubble
+          generate_render_js("BubbleChart")
+        when :curve
+          generate_render_js("LineChart")
+        else
+          raise NotImplementedError
         end
       end
 
-      def x_labels
-        [].tap do |label|
-          context.series.each do |series|
-            series.xs.each do |xs_data|
-              label << xs_data unless label.any? { |label| label == xs_data }
-            end
+      private
+
+        def google_charts_load_tag
+          if self.class.with_api_load_tag
+            "<script type='text/javascript' src='#{self.class.google_charts_src}'></script>"
+          else
+            nil
           end
         end
-      end
 
-      def data_hash
-        {}.tap do |hash|
-          context.series.to_a.each_with_index do |series_data, series_index|
-            x_labels.sort.each do |x_label|
-              unless hash[x_label]
-                hash[x_label] = []
-              end
+        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
+          when :curve
+            column_js = "data.addColumn('number', '#{context.xlabel}');"
+            context.series.to_a.each_with_index do |series_data, index|
+              column_js << "data.addColumn('number', '#{series_data.label || index}');"
+            end
+          else
+            column_js = "data.addColumn('string', '#{context.xlabel}');"
+            context.series.to_a.each_with_index do |series_data, index|
+              column_js << "data.addColumn('number', '#{series_data.label || index}');"
+            end
+          end
+
+          column_js
+        end
 
-              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"
+        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
             end
           end
         end
-      end
 
-      def formatted_data_array
-        case context.method
-        when :bubble
-          [["ID", "X", "Y", "GROUP", "SIZE"]].tap do |data_array|
+        def data_hash
+          {}.tap do |hash|
             context.series.to_a.each_with_index do |series_data, series_index|
-              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[:label] || series_index,
-                  series_data.zs.to_a[data_index] || "null",
-                ]
+              x_labels.each do |x_label|
+                unless hash[x_label]
+                  hash[x_label] = []
+                end
+
+                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"
+                end
               end
             end
           end
-        else
-          [headers.map(&:to_s)].tap do |data_array|
-            data_hash.each do |k, v|
-              data_array << [k.to_s, v].flatten
+        end
+
+        def formatted_data_array
+          case context.method
+          when :bubble
+            [].tap do |data_array|
+              context.series.to_a.each_with_index do |series_data, series_index|
+                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[:label] || series_index.to_s,
+                    series_data.zs.to_a[data_index] || "null",
+                  ]
+                end
+              end
+            end
+          when :curve
+            [].tap do |data_array|
+              data_hash.each do |k, v|
+                data_array << [k, v].flatten
+              end
+            end
+          else
+            [].tap do |data_array|
+              data_hash.each do |k, v|
+                data_array << [k.to_s, v].flatten
+              end
             end
           end
         end
-      end
 
-      def x_range_option
-        x_range = context&.range&.fetch(:x, nil)
-        {
-          max: x_range&.max,
-          min: x_range&.min,
-        }.reject { |_k, v| v.nil? }
-      end
+        def x_range_option
+          x_range = if context.method != :barh
+                      context&.range&.fetch(:x, nil)
+                    else
+                      context&.range&.fetch(:y, nil)
+                    end
+          {
+            max: x_range&.max,
+            min: x_range&.min,
+          }.reject { |_k, v| v.nil? }
+        end
 
-      def y_range_option
-        y_range = context&.range&.fetch(:y, nil)
-        {
-          max: y_range&.max,
-          min: y_range&.min,
-        }.reject { |_k, v| v.nil? }
-      end
+        def y_range_option
+          y_range = if context.method != :barh
+                      context&.range&.fetch(:y, nil)
+                    else
+                      context&.range&.fetch(:x, nil)
+                    end
+          {
+            max: y_range&.max,
+            min: y_range&.min,
+          }.reject { |_k, v| v.nil? }
+        end
 
-      def generate_render_js(chart_type)
-        js = <<-JS
-          #{google_chart_load_tag}
-          <script type="text/javascript">
-            google.charts.load("current", {packages:["corechart"]});
-            google.charts.setOnLoadCallback(drawChart);
-            function drawChart() {
-              const data = google.visualization.arrayToDataTable(
-                #{formatted_data_array}
-              );
-
-              const view = new google.visualization.DataView(data);
-
-              const options = {
-                title: "#{context.title}",
-                vAxis: {
-                  title: "#{context.ylabel}",
-                  viewWindow: {
-                    max: #{y_range_option[:max] || "null"},
-                    min: #{y_range_option[:min] || "null"},
+        def generate_render_js(chart_type)
+          js = <<-JS
+            #{google_charts_load_tag unless self.class.chart_id > 1}
+            <script type="text/javascript">
+              google.charts.load("current", {packages:["corechart"]});
+              google.charts.setOnLoadCallback(drawChart);
+              function drawChart() {
+                const data = new google.visualization.DataTable();
+                #{data_column_js}
+                data.addRows(#{formatted_data_array})
+
+                const view = new google.visualization.DataView(data);
+
+                const options = {
+                  title: "#{context.title}",
+                  vAxis: {
+                    title: "#{context.ylabel}",
+                    viewWindow: {
+                      max: #{y_range_option[:max] || "null"},
+                      min: #{y_range_option[:min] || "null"},
+                    },
                   },
-                },
-                hAxis: {
-                  title: "#{context.xlabel}",
-                  viewWindow: {
-                    max: #{x_range_option[:max] || "null"},
-                    min: #{x_range_option[:min] || "null"},
-                  }
-                },
-                legend: { position: "none" },
-              };
-              const chart = new google.visualization.#{chart_type}(document.getElementById("#{chart_type}-#{self.class.chart_id}"));
-              chart.draw(view, options);
-            }
-          </script>
-          <div id="#{chart_type}-#{self.class.chart_id}" style="width: 900px; height: 300px;"></div>
-        JS
-      end
+                  hAxis: {
+                    title: "#{context.xlabel}",
+                    viewWindow: {
+                      max: #{x_range_option[:max] || "null"},
+                      min: #{x_range_option[:min] || "null"},
+                    }
+                  },
+                  legend: { position: "none" },
+                };
+                const chart = new google.visualization.#{chart_type}(document.getElementById("#{chart_type}-#{self.class.chart_id}"));
+                chart.draw(view, options);
+              }
+            </script>
+            <div id="#{chart_type}-#{self.class.chart_id}" style="width: 900px; height: 300px;"></div>
+          JS
+          js.gsub!(/\"null\"/, 'null')
+          js
+        end
+    end
   end
 end