charty 0.2.0 → 0.2.6

data/lib/charty.rb

@@ -1,8 +1,20 @@
 require_relative "charty/version"
 
+require "colors"
+require "palette"
+
+require_relative "charty/util"
+require_relative "charty/dash_pattern_generator"
 require_relative "charty/backends"
+require_relative "charty/backend_methods"
 require_relative "charty/plotter"
+require_relative "charty/index"
 require_relative "charty/layout"
 require_relative "charty/linspace"
-require_relative "charty/table_adapters"
+require_relative "charty/plotters"
+require_relative "charty/plot_methods"
 require_relative "charty/table"
+require_relative "charty/table_adapters"
+require_relative "charty/statistics"
+require_relative "charty/vector_adapters"
+require_relative "charty/vector"

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,8 +72,9 @@ 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"
 require "charty/backends/rubyplot"
+require "charty/backends/unicode_plot"

data/lib/charty/backends/bokeh.rb

@@ -17,13 +17,13 @@ module Charty
         @series = series
       end
 
-      def render(context, filename)
+      def old_style_render(context, filename)
         plot = plot(context)
         save(plot, context, filename)
         PyCall.import_module('bokeh.io').show(plot)
       end
 
-      def save(plot, context, filename)
+      def old_style_save(plot, context, filename)
         if filename
           PyCall.import_module('bokeh.io').save(plot, filename)
         end
@@ -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
 
@@ -33,7 +33,7 @@ module Charty
         @series = series
       end
 
-      def render(context, filename)
+      def old_style_render(context, filename)
         plot(nil, context)
       end
 
@@ -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/gruff.rb

@@ -26,7 +26,7 @@ module Charty
         raise NotImplementedError
       end
 
-      def render(context, filename="")
+      def old_style_render(context, filename="")
         FileUtils.mkdir_p(File.dirname(filename))
         plot(@plot, context).write(filename)
       end
@@ -83,7 +83,7 @@ module Charty
           p.x_axis_label = context.xlabel if context.xlabel
           p.y_axis_label = context.ylabel if context.ylabel
           context.series.each do |data|
-            p.data(data.label, data.xs.to_a)
+            p.dataxy(data.label, data.xs.to_a, data.ys.to_a)
           end
           p
         when :scatter
@@ -99,7 +99,18 @@ module Charty
           # refs. https://github.com/topfunky/gruff/issues/163
           raise NotImplementedError
         when :hist
-          raise NotImplementedError
+          p = plot::Histogram.new
+          p.title = context.title if context.title
+          p.x_axis_label = context.xlabel if context.xlabel
+          p.y_axis_label = context.ylabel if context.ylabel
+          if context.range_x
+            p.minimum_bin = context.range_x.first
+            p.maximum_bin = context.range_x.last
+          end
+          context.data.each do |data|
+            p.data('', data.to_a)
+          end
+          p
         end
       end
     end

data/lib/charty/backends/plotly.rb

@@ -1,4 +1,6 @@
-require 'json'
+require "json"
+require "securerandom"
+require "tmpdir"
 
 module Charty
   module Backends
@@ -35,7 +37,7 @@ module Charty
         @series = series
       end
 
-      def render(context, filename)
+      def old_style_render(context, filename)
         plot(nil, context)
       end
 
@@ -55,24 +57,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 +95,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 +104,771 @@ 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 = {showlegend: false}
+      end
+
+      def bar(bar_pos, group_names, values, colors, orient, label: nil, width: 0.8r,
+              align: :center, conf_int: nil, error_colors: nil, error_width: nil, cap_size: nil)
+        bar_pos = Array(bar_pos)
+        values = Array(values)
+        colors = Array(colors).map(&:to_hex_string)
+
+        if orient == :v
+          x, y = bar_pos, values
+          x = group_names unless group_names.nil?
+        else
+          x, y = values, bar_pos
+          y = group_names unless group_names.nil?
+        end
+
+        trace = {
+          type: :bar,
+          orientation: orient,
+          x: x,
+          y: y,
+          width: width,
+          marker: {color: colors}
+        }
+        trace[:name] = label unless label.nil?
+
+        unless conf_int.nil?
+          errors_low = conf_int.map.with_index {|(low, _), i| values[i] - low }
+          errors_high = conf_int.map.with_index {|(_, high), i| high - values[i] }
+
+          error_bar = {
+            type: :data,
+            visible: true,
+            symmetric: false,
+            array: errors_high,
+            arrayminus: errors_low,
+            color: error_colors[0].to_hex_string
+          }
+          error_bar[:thickness] = error_width unless error_width.nil?
+          error_bar[:width] = cap_size unless cap_size.nil?
+
+          error_bar_key = orient == :v ? :error_y : :error_x
+          trace[error_bar_key] = error_bar
+        end
+
+        @traces << trace
+
+        if group_names
+          @layout[:barmode] = :group
+        end
+      end
+
+      def box_plot(plot_data, group_names,
+                   orient:, colors:, gray:, dodge:, width: 0.8r,
+                   flier_size: 5, whisker: 1.5, notch: false)
+        colors = Array(colors).map(&:to_hex_string)
+        gray = gray.to_hex_string
+        width = Float(width)
+        flier_size = Float(width)
+        whisker = Float(whisker)
+
+        traces = plot_data.map.with_index do |group_data, i|
+          group_data = Array(group_data)
+          trace = {
+            type: :box,
+            orientation: orient,
+            name: group_names[i],
+            marker: {color: colors[i]}
+          }
+          if orient == :v
+            trace.update(y: group_data)
+          else
+            trace.update(x: group_data)
+          end
+
+          trace
+        end
+
+        traces.reverse! if orient == :h
+
+        @traces.concat(traces)
+      end
+
+      def grouped_box_plot(plot_data, group_names, color_names,
+                           orient:, colors:, gray:, dodge:, width: 0.8r,
+                           flier_size: 5, whisker: 1.5, notch: false)
+        colors = Array(colors).map(&:to_hex_string)
+        gray = gray.to_hex_string
+        width = Float(width)
+        flier_size = Float(width)
+        whisker = Float(whisker)
+
+        @layout[:boxmode] = :group
+
+        if orient == :h
+          @layout[:xaxis] ||= {}
+          @layout[:xaxis][:zeroline] = false
+
+          plot_data = plot_data.map {|d| d.reverse }
+          group_names = group_names.reverse
+        end
+
+        traces = color_names.map.with_index do |color_name, i|
+          group_keys = group_names.flat_map.with_index { |name, j|
+            Array.new(plot_data[i][j].length, name)
+          }.flatten
+
+          values = plot_data[i].flat_map {|d| Array(d) }
+
+          trace = {
+            type: :box,
+            orientation: orient,
+            name: color_name,
+            marker: {color: colors[i]}
+          }
+
+          if orient == :v
+            trace.update(y: values, x: group_keys)
+          else
+            trace.update(x: values, y: group_keys)
+          end
+
+          trace
+        end
+
+        @traces.concat(traces)
+      end
+
+      def scatter(x, y, variables, color:, color_mapper:,
+                  style:, style_mapper:, size:, size_mapper:)
+        orig_x, orig_y = x, y
+
+        x = case x
+            when Charty::Vector
+              x.to_a
+            else
+              Array.try_convert(x)
+            end
+        if x.nil?
+          raise ArgumentError, "Invalid value for x: %p" % orig_x
+        end
+
+        y = case y
+            when Charty::Vector
+              y.to_a
+            else
+              Array.try_convert(y)
+            end
+        if y.nil?
+          raise ArgumentError, "Invalid value for y: %p" % orig_y
+        end
+
+        unless color.nil? && style.nil?
+          grouped_scatter(x, y, variables,
+                          color: color, color_mapper: color_mapper,
+                          style: style, style_mapper: style_mapper,
+                          size: size, size_mapper: size_mapper)
+          return
+        end
+
+        trace = {
+          type: :scatter,
+          mode: :markers,
+          x: x,
+          y: y,
+          marker: {
+            line: {
+              width: 1,
+              color: "#fff"
+            },
+            size: 10
+          }
+        }
+
+        unless size.nil?
+          trace[:marker][:size] = size_mapper[size].map {|x| 6.0 + x * 6.0 }
+        end
+
+        @traces << trace
+      end
+
+      private def grouped_scatter(x, y, variables, color:, color_mapper:,
+                                  style:, style_mapper:, size:, size_mapper:)
+        @layout[:showlegend] = true
+
+        groups = (0 ... x.length).group_by do |i|
+          key = {}
+          key[:color] = color[i] unless color.nil?
+          key[:style] = style[i] unless style.nil?
+          key
+        end
+
+        groups.each do |group_key, indices|
+          trace = {
+            type: :scatter,
+            mode: :markers,
+            x: x.values_at(*indices),
+            y: y.values_at(*indices),
+            marker: {
+              line: {
+                width: 1,
+                color: "#fff"
+              },
+              size: 10
+            }
+          }
+
+          unless size.nil?
+            vals = size.values_at(*indices)
+            trace[:marker][:size] = size_mapper[vals].map do |x|
+              scale_scatter_point_size(x).to_f
+            end
+          end
+
+          name = []
+          legend_title = []
+
+          if group_key.key?(:color)
+            trace[:marker][:color] = color_mapper[group_key[:color]].to_hex_string
+            name << group_key[:color]
+            legend_title << variables[:color]
+          end
+
+          if group_key.key?(:style)
+            trace[:marker][:symbol] = style_mapper[group_key[:style], :marker]
+            name << group_key[:style]
+            legend_title << variables[:style]
+          end
+
+          trace[:name] = name.uniq.join(", ") unless name.empty?
+
+          @traces << trace
+
+          unless legend_title.empty?
+            @layout[:legend] ||= {}
+            @layout[:legend][:title] = {text: legend_title.uniq.join(", ")}
+          end
+        end
+      end
+
+      def add_scatter_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        if legend == :full
+          warn("Plotly backend does not support full verbosity legend")
+        end
+      end
+
+      private def scale_scatter_point_size(x)
+        min = 6
+        max = 12
+
+        min + x * (max - min)
+      end
+
+      def line(x, y, variables, color:, color_mapper:, size:, size_mapper:, style:, style_mapper:, ci_params:)
+        x = case x
+            when Charty::Vector
+              x.to_a
+            else
+              orig_x, x = x, Array.try_convert(x)
+              if x.nil?
+                raise ArgumentError, "Invalid value for x: %p" % orig_x
+              end
+            end
+
+        y = case y
+            when Charty::Vector
+              y.to_a
+            else
+              orig_y, y = y, Array.try_convert(y)
+              if y.nil?
+                raise ArgumentError, "Invalid value for y: %p" % orig_y
+              end
+            end
+
+        name = []
+        legend_title = []
+
+        if color.nil?
+          # TODO: do not hard code this
+          line_color = Colors["#1f77b4"] # the first color of D3's category10 palette
+        else
+          line_color = color_mapper[color].to_rgb
+          name << color
+          legend_title << variables[:color]
+        end
+
+        unless style.nil?
+          marker, dashes = style_mapper[style].values_at(:marker, :dashes)
+          name << style
+          legend_title << variables[:style]
+        end
+
+        trace = {
+          type: :scatter,
+          mode: marker.nil? ? "lines" : "lines+markers",
+          x: x,
+          y: y,
+          line: {
+            shape: :linear,
+            color: line_color.to_hex_string
+          }
+        }
+
+        default_line_width = 2.0
+        unless size.nil?
+          line_width = default_line_width + 2.0 * size_mapper[size]
+          trace[:line][:width] = line_width
+        end
+
+        unless dashes.nil?
+          trace[:line][:dash] = convert_dash_pattern(dashes, line_width || default_line_width)
+        end
+
+        unless marker.nil?
+          trace[:marker] = {
+            line: {
+              width: 1,
+              color: "#fff"
+            },
+            symbol: marker,
+            size: 10
+          }
+        end
+
+        unless ci_params.nil?
+          case ci_params[:style]
+          when :band
+            y_min = ci_params[:y_min].to_a
+            y_max = ci_params[:y_max].to_a
+            @traces << {
+              type: :scatter,
+              x: x,
+              y: y_max,
+              mode: :lines,
+              line: { shape: :linear, width: 0 },
+              showlegend: false
+            }
+            @traces << {
+              type: :scatter,
+              x: x,
+              y: y_min,
+              mode: :lines,
+              line: { shape: :linear, width: 0 },
+              fill: :tonexty,
+              fillcolor: line_color.to_rgba(alpha: 0.2).to_hex_string,
+              showlegend: false
+            }
+          when :bars
+            y_min = ci_params[:y_min].map.with_index {|v, i| y[i] - v }
+            y_max = ci_params[:y_max].map.with_index {|v, i| v - y[i] }
+            trace[:error_y] = {
+              visible: true,
+              type: :data,
+              array: y_max,
+              arrayminus: y_min
+            }
+            unless line_color.nil?
+              trace[:error_y][:color] = line_color
+            end
+            unless line_width.nil?
+              trace[:error_y][:thickness] = line_width
+            end
+          end
+        end
+
+        trace[:name] = name.uniq.join(", ") unless name.empty?
+
+        @traces << trace
+
+        unless legend_title.empty?
+          @layout[:showlegend] = true
+          @layout[:legend] ||= {}
+          @layout[:legend][:title] = {text: legend_title.uniq.join(", ")}
+        end
+      end
+
+      def add_line_plot_legend(variables, color_mapper, size_mapper, style_mapper, legend)
+        if legend == :full
+          warn("Plotly backend does not support full verbosity legend")
+        end
+
+        legend_order = if variables.key?(:color)
+                         if variables.key?(:style)
+                           # both color and style
+                           color_mapper.levels.product(style_mapper.levels)
+                         else
+                           # only color
+                           color_mapper.levels
+                         end
+                       elsif variables.key?(:style)
+                         # only style
+                         style_mapper.levels
+                       else
+                         # no legend entries
+                         nil
+                       end
+
+        if legend_order
+          # sort traces
+          legend_index = legend_order.map.with_index { |name, i|
+            [Array(name).uniq.join(", "), i]
+          }.to_h
+          @traces = @traces.each_with_index.sort_by { |trace, trace_index|
+            index = legend_index.fetch(trace[:name], legend_order.length)
+            [index, trace_index]
+          }.map(&:first)
+
+          # remove duplicated legend entries
+          names = {}
+          @traces.each do |trace|
+            if trace[:showlegend] != false
+              name = trace[:name]
+              if name
+                if names.key?(name)
+                  # Hide duplications
+                  trace[:showlegend] = false
+                else
+                  trace[:showlegend] = true
+                  names[name] = true
+                end
+              else
+                # Hide no name trace in legend
+                trace[:showlegend] = false
+              end
+            end
+          end
+        end
+      end
+
+      private def convert_dash_pattern(pattern, line_width)
+        case pattern
+        when ""
+          :solid
+        else
+          pattern.map {|d| "#{line_width * d}px" }.join(",")
+        end
+      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_yticks(values)
+        @layout[:yaxis] ||= {}
+        @layout[:yaxis][:tickmode] = "array"
+        @layout[:yaxis][:tickvals] = values
+      end
+
+      def set_xtick_labels(labels)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:tickmode] = "array"
+        @layout[:xaxis][:ticktext] = labels
+      end
+
+      def set_ytick_labels(labels)
+        @layout[:yaxis] ||= {}
+        @layout[:yaxis][:tickmode] = "array"
+        @layout[:yaxis][:ticktext] = labels
+      end
+
+      def set_xlim(min, max)
+        @layout[:xaxis] ||= {}
+        @layout[:xaxis][:range] = [min, max]
+      end
+
+      def set_ylim(min, max)
+        @layout[:yaxis] ||= {}
+        @layout[:yaxis][:range] = [min, max]
+      end
+
+      def disable_xaxis_grid
+        # do nothing
+      end
+
+      def disable_yaxis_grid
+        # do nothing
+      end
+
+      def invert_yaxis
+        @traces.each do |trace|
+          case trace[:type]
+          when :bar
+            trace[:y].reverse!
+          end
+        end
+
+        if @layout[:boxmode] == :group
+          @traces.reverse!
+        end
+
+        if @layout[:yaxis] && @layout[:yaxis][:ticktext]
+          @layout[:yaxis][:ticktext].reverse!
+        end
+      end
+
+      def legend(loc:, title:)
+        @layout[:showlegend] = true
+        @layout[:legend] = {
+          title: {
+            text: title
+          }
+        }
+        # TODO: Handle loc
+      end
+
+      def save(filename, format: nil, title: nil, width: 700, height: 500, **kwargs)
+        format = detect_format(filename) if format.nil?
+
+        case format
+        when nil, :html, "text/html"
+          save_html(filename, title: title, **kwargs)
+        when :png, "png", "image/png",
+             :jpeg, "jpeg", "image/jpeg"
+          render_image(format, filename: filename, notebook: false, title: title, width: width, height: height, **kwargs)
+        end
+        nil
+      end
+
+      private def detect_format(filename)
+        case File.extname(filename).downcase
+        when ".htm", ".html"
+          :html
+        when ".png"
+          :png
+        when ".jpg", ".jpeg"
+          :jpeg
+        else
+          raise ArgumentError,
+                "Unable to infer file type from filename: %p" % filename
+        end
+      end
+
+      private def save_html(filename, title:, element_id: nil)
+        html = <<~HTML
+          <!DOCTYPE html>
+          <html>
+          <head>
+          <meta charset="utf-8">
+          <title>%{title}</title>
+          <script src="https://cdn.plot.ly/plotly-latest.min.js"></script>
+          </head>
+          <body>
+          <div id="%{id}" style="width: 100%%; height:100%%;"></div>
+          <script type="text/javascript">
+          Plotly.newPlot("%{id}", %{data}, %{layout});
+          </script>
+          </body>
+          </html>
+        HTML
+
+        element_id = SecureRandom.uuid if element_id.nil?
+
+        html %= {
+          title: title || default_html_title,
+          id: element_id,
+          data: JSON.dump(@traces),
+          layout: JSON.dump(@layout)
+        }
+        File.write(filename, html)
+      end
+
+      private def default_html_title
+        "Charty plot"
+      end
+
+      def render(element_id: nil, format: nil, notebook: false)
+        case format
+        when :html, "html"
+          format = "text/html"
+        when :png, "png"
+          format = "image/png"
+        when :jpeg, "jpeg"
+          format = "image/jpeg"
+        end
+
+        case format
+        when "text/html", nil
+          # render html after this case cause
+        when "image/png", "image/jpeg"
+          image_data = render_image(format, element_id: element_id, notebook: false)
+          if notebook
+            return [format, image_data]
+          else
+            return image_data
+          end
+        else
+          raise ArgumentError,
+                "Unsupported mime type to render: %p" % format
+        end
+
+        # TODO: size should be customizable
+        html = <<~HTML
+          <div id="%{id}" style="width: 100%%; height:525px;"></div>
+          <script type="text/javascript">
+            requirejs(["plotly"], function (Plotly) {
+              Plotly.newPlot("%{id}", %{data}, %{layout});
+            });
+          </script>
+        HTML
+
+        element_id = SecureRandom.uuid if element_id.nil?
+
+        html %= {
+          id: element_id,
+          data: JSON.dump(@traces),
+          layout: JSON.dump(@layout)
+        }
+
+        if notebook
+          IRubyOutput.prepare
+          ["text/html", html]
+        else
+          html
+        end
+      end
+
+      private def render_image(format=nil, filename: nil, element_id: nil, notebook: false,
+                       title: nil, width: nil, height: nil)
+        format = "image/png" if format.nil?
+        case format
+        when :png, "png", :jpeg, "jpeg"
+          image_type = format.to_s
+        when "image/png", "image/jpeg"
+          image_type = format.split("/").last
+        else
+          raise ArgumentError,
+                "Unsupported mime type to render image: %p" % format
+        end
+
+        height = 525 if height.nil?
+        width = (height * Math.sqrt(2)).to_i if width.nil?
+        title = "Charty plot" if title.nil?
+
+        element_id = SecureRandom.uuid if element_id.nil?
+        element_id = "charty-plotly-#{element_id}"
+        Dir.mktmpdir do |tmpdir|
+          html_filename = File.join(tmpdir, "%s.html" % element_id)
+          save_html(html_filename, title: title, element_id: element_id)
+          return self.class.render_image(html_filename, filename, image_type, element_id, width, height)
+        end
+      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
+
+      @playwright_fiber = nil
+
+      def self.ensure_playwright
+        if @playwright_fiber.nil?
+          begin
+            require "playwright"
+          rescue LoadError
+            $stderr.puts "ERROR: You need to install playwright and playwright-ruby-client before using Plotly renderer"
+            raise
+          end
+
+          @playwright_fiber = Fiber.new do
+            playwright_cli_executable_path = ENV.fetch("PLAYWRIGHT_CLI_EXECUTABLE_PATH", "npx playwright")
+            Playwright.create(playwright_cli_executable_path: playwright_cli_executable_path) do |playwright|
+              playwright.chromium.launch(headless: true) do |browser|
+                request = Fiber.yield
+                loop do
+                  result = nil
+                  case request.shift
+                  when :finish
+                    break
+                  when :render
+                    input, output, format, element_id, width, height = request
+
+                    page = browser.new_page
+                    page.set_viewport_size(width: width, height: height)
+                    page.goto("file://#{input}")
+                    element = page.query_selector("\##{element_id}")
+
+                    kwargs = {type: format}
+                    kwargs[:path] = output unless output.nil?
+                    result = element.screenshot(**kwargs)
+                  end
+                  request = Fiber.yield(result)
+                end
+              end
+            end
+          end
+          @playwright_fiber.resume
+        end
+      end
+
+      def self.terminate_playwright
+        return if @playwright_fiber.nil?
+
+        @playwright_fiber.resume([:finish])
+      end
+
+      at_exit { terminate_playwright }
+
+      def self.render_image(input, output, format, element_id, width, height)
+        ensure_playwright if @playwright_fiber.nil?
+        @playwright_fiber.resume([:render, input, output, format.to_s, element_id, width, height])
+      end
     end
   end
 end