charty 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 63e13663e8213e077993e52b906b630c35a1f7f9a224abb99fd206bb700659c2
-  data.tar.gz: d7fd53056c32c18bf5af6b1e1a4b2a29bfe652a427b338087d3cab538a0797ba
+  metadata.gz: 6e39148cc6e6fd7916cdfbe5dacda3bab8f95068cbe3ceb4dff673d9688487d0
+  data.tar.gz: 5743d17f30055707fe39004f99bb30fb2cb10b164dbf9b222f000068cc800708
 SHA512:
-  metadata.gz: cc4da146432f688eb52dd382ea516e02ab84ef7143453c80fa5bc14fef55851728550ee58fe98c1c3a5e9a1eac0f33dcfb702356bc7c0f344ceaf85f87400435
-  data.tar.gz: f519610073317c3fafd42b97ad5e96d124265f6a7d79a54023995cf82d1fe84624d4f914c26e3eef644ad280110400fe1cdac275ec5e32145d7e4b652ef47891
+  metadata.gz: 562b312fb4ca59995d19930f404d6162f432f7731752e5a9016132b6b2696a507f6d7523d5eb6e5bc0141273726d2608b1351b497f2c200cec0fda5204e4fc19
+  data.tar.gz: 213f83930bc1bd809ae98af41d0608793c356b234064e9f2ec79b96e76b1c301a331fc44c9c04fc0f3f188f65b780b59af449dca206f68ec310cb121b6bd0e41

data/charty.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "red-colors", ">= 0.3.0"
+  spec.add_dependency "red-datasets", ">= 0.1.2"
   spec.add_dependency "red-palette", ">= 0.5.0"
 
   spec.add_dependency "matplotlib", ">= 1.2.0"
@@ -36,7 +37,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", ">= 1.16"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "test-unit"
-  spec.add_development_dependency "red-datasets", ">= 0.1.2"
   spec.add_development_dependency "daru"
   spec.add_development_dependency "matrix" # need for daru on Ruby > 3.0
   spec.add_development_dependency "activerecord"

data/lib/charty.rb

@@ -3,7 +3,9 @@ require_relative "charty/version"
 require "colors"
 require "palette"
 
+require_relative "charty/cache_dir"
 require_relative "charty/util"
+require_relative "charty/iruby_helper"
 require_relative "charty/dash_pattern_generator"
 require_relative "charty/backends"
 require_relative "charty/backend_methods"

data/lib/charty/backends/plotly.rb

@@ -2,6 +2,10 @@ require "json"
 require "securerandom"
 require "tmpdir"
 
+require_relative "plotly_helpers/html_renderer"
+require_relative "plotly_helpers/notebook_renderer"
+require_relative "plotly_helpers/plotly_renderer"
+
 module Charty
   module Backends
     class Plotly
@@ -558,6 +562,52 @@ module Charty
         end
       end
 
+      PLOTLY_HISTNORM = {
+        count: "".freeze,
+        frequency: "density".freeze,
+        density: "probability density".freeze,
+        probability: "probability".freeze
+      }.freeze
+
+      def univariate_histogram(data, name, variable_name, stat,
+                               bin_start, bin_end, bin_size, alpha,
+                               color, color_mapper)
+        orientation = case variable_name
+                      when :x
+                        :v
+                      else
+                        :h
+                      end
+        trace = {
+          type: "histogram",
+          name: name.to_s,
+          variable_name => data.to_a,
+          orientation: orientation,
+          histnorm: PLOTLY_HISTNORM[stat],
+          "#{variable_name}bins": {
+            start: bin_start,
+            end: bin_end,
+            size: bin_size
+          },
+          opacity: alpha
+        }
+
+        if color
+          trace[:marker] = {
+            color: color_mapper[color].to_rgb.to_hex_string
+          }
+        end
+
+        @traces << trace
+
+        @layout[:bargap] = 0.05
+
+        if @traces.length > 1
+          @layout[:barmode] = "overlay"
+          @layout[:showlegend] = true
+        end
+      end
+
       def set_xlabel(label)
         @layout[:xaxis] ||= {}
         @layout[:xaxis][:title] = label
@@ -699,7 +749,7 @@ module Charty
 
       def render(element_id: nil, format: nil, notebook: false)
         case format
-        when :html, "html"
+        when :html, "html", nil
           format = "text/html"
         when :png, "png"
           format = "image/png"
@@ -708,7 +758,7 @@ module Charty
         end
 
         case format
-        when "text/html", nil
+        when "text/html"
           # render html after this case cause
         when "image/png", "image/jpeg"
           image_data = render_image(format, element_id: element_id, notebook: false)
@@ -722,32 +772,54 @@ module Charty
                 "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)
-        }
-
+        renderer = PlotlyHelpers::HtmlRenderer.new(full_html: !notebook)
+        html = renderer.render({data: @traces, layout: @layout}, element_id: element_id)
         if notebook
-          IRubyOutput.prepare
-          ["text/html", html]
+          [format, html]
         else
           html
         end
       end
 
+      def render_mimebundle(include: [], exclude: [])
+        types = case
+               when IRubyHelper.vscode?,
+                 IRubyHelper.nteract?
+                 [:plotly_mimetype]
+               else
+                 [:plotly_mimetype, :notebook]
+               end
+        bundle = Util.filter_map(types) { |type|
+          case type
+          when :plotly_mimetype
+            render_plotly_mimetype_bundle
+          when :notebook
+            render_notebook_bundle
+          end
+        }.to_h
+        bundle
+      end
+
+      private def render_plotly_mimetype_bundle
+        renderer = PlotlyHelpers::PlotlyRenderer.new
+        obj = renderer.render({data: @traces, layout: @layout})
+        [ "application/vnd.plotly.v1+json", obj ]
+      end
+
+      private def render_notebook_bundle
+        renderer = self.class.notebook_renderer
+        renderer.activate
+        html = renderer.render({data: @traces, layout: @layout})
+        [ "text/html", html ]
+      end
+
+      # for new APIs
+      def self.notebook_renderer
+        @notebook_renderer ||= PlotlyHelpers::NotebookRenderer.new
+      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?

data/lib/charty/backends/plotly_helpers/html_renderer.rb

@@ -0,0 +1,203 @@
+require "datasets/downloader"
+require "json"
+require "securerandom"
+
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class HtmlRenderer
+        def initialize(use_cdn: true,
+                       full_html: false,
+                       requirejs: true)
+          @use_cdn = use_cdn
+          @full_html = full_html
+          @requirejs = requirejs
+        end
+
+        PLOTLY_URL = "https://plot.ly".freeze
+        PLOTLY_LATEST_CDN_URL = "https://cdn.plot.ly/plotly-latest.min.js".freeze
+        MATHJAX_CDN_URL = ("https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js").freeze
+
+        DEFAULT_WIDTH = "100%".freeze
+        DEFAULT_HEIGHT = 525
+
+        def render(figure, element_id: nil, post_script: nil)
+          element_id = SecureRandom.uuid if element_id.nil?
+          plotly_html_div = build_plotly_html_div(figure, element_id, post_script)
+
+          if @full_html
+            <<~END_HTML % {div: plotly_html_div}
+              <!DOCTYPE html>
+              <html>
+              <head><meta charset="utf-8" /></head>
+              <body>
+                %{div}
+              </body>
+              </html>
+            END_HTML
+          else
+            plotly_html_div
+          end
+        end
+
+        private def build_plotly_html_div(figure, element_id, post_script)
+          layout = figure.fetch(:layout, {})
+
+          json_data = JSON.dump(figure.fetch(:data, []))
+          json_layout = JSON.dump(layout)
+          json_frames = JSON.dump(figure[:frames]) if figure.key?(:frames)
+
+          # TODO: config and responsive support
+
+          template = layout.fetch(:template, {}).fetch(:layout, {})
+          div_width = layout.fetch(:width, template.fetch(:width, DEFAULT_WIDTH))
+          div_height = layout.fetch(:height, template.fetch(:height, DEFAULT_HEIGHT))
+
+          div_width  = "#{div_width}px"  if Float(div_width, exception: false)
+          div_height = "#{div_height}px" if Float(div_height, exception: false)
+
+          # TODO: showLink and showSendToCloud support
+          base_url_line = "window.PLOTLYENV.BASE_URL = '%{url}';" % {url: PLOTLY_URL}
+
+          ## build script body
+
+          # TODO: post_script support
+          then_post_script = ""
+          if post_script
+            ary = Array.try_convert(post_script)
+            post_script = ary || [post_script]
+            post_script.each do |ps|
+              next if ps.nil?
+              then_post_script << '.then(function(){ %{post_script} })' % {
+                post_script: ps % {plot_id: element_id}
+              }
+            end
+          end
+
+          then_addframes = ""
+          then_animate = ""
+          if json_frames
+            then_addframes = <<~END_ADDFRAMES % {id: element_id, frames: json_frames}
+              .then(function(){
+                Plotly.addFrames('%{id}', {frames});
+              })
+            END_ADDFRAMES
+
+            # TODO: auto_play support
+          end
+
+          json_config = JSON.dump({}) # TODO: config support
+
+          script = <<~END_SCRIPT
+            if (document.getElementById("%{id}")) {
+              Plotly.newPlot("%{id}", %{data}, %{layout}, %{config})%{then_addframes}%{then_animate}%{then_post_script};
+            }
+          END_SCRIPT
+          script = script % {
+            id: element_id,
+            data: json_data,
+            layout: json_layout,
+            config: json_config,
+            then_addframes: then_addframes,
+            then_animate: then_animate,
+            then_post_script: then_post_script
+          }
+
+          ## Handle loading/initializing plotlyjs
+
+          case
+          when @requirejs
+            include_plotlyjs = :require
+            include_mathjax = false
+          when @use_cdn
+            include_plotlyjs = :cdn
+            include_mathjax = :cdn
+          else
+            include_plotlyjs = true
+            include_mathjax = :cdn
+          end
+
+          case include_plotlyjs
+          when :require
+            require_start = 'require(["plotly"], function (Plotly) {'
+            require_end   = '});'
+          when :cdn
+            load_plotlyjs = <<~END_LOAD_PLOTLYJS % {win_config: window_plotly_config, url: PLOTLY_LATEST_CDN_URL}
+              %{win_config}
+              <script src="%{url}"></script>
+            END_LOAD_PLOTLYJS
+          when true
+            load_plotlyjs = <<~END_LOAD_PLOTLYJS % {win_config: window_plotly_config, script: get_plotlyjs}
+              %{win_config}
+              <script type="text/javascript">%{script}</script>
+            END_LOAD_PLOTLYJS
+          end
+
+          ## Handle loading/initializing MathJax
+
+          mathjax_tmplate = %Q[<script src="%{url}?config=TeX-AMS-MML_SVG"></script>]
+          case include_mathjax
+          when :cdn
+            mathjax_script = mathjax_tmplate % {url: MATHJAX_CDN_URL}
+            mathjax_script << <<~END_SCRIPT % {mathjax_config: mathjax_config}
+              <script type="text/javascript">%{mathjax_config}</script>
+            END_SCRIPT
+          else
+            mathjax_script = ""
+          end
+
+          div_template = <<~END_DIV
+            <div>
+              %{mathjax_script}
+              %{load_plotlyjs}
+              <div id="%{id}" class="plotly-graph-div" style="height: %{height}; width: %{width};"></div>
+              <script type="text/javascript">
+                %{require_start}
+                  window.PLOTLYENV = window.PLOTLYENV || {};
+                  %{base_url_line}
+                  %{script}
+                %{require_end}
+              </script>
+            </div>
+          END_DIV
+
+          plotly_html_div = div_template % {
+            mathjax_script: mathjax_script,
+            load_plotlyjs: load_plotlyjs,
+            id: element_id,
+            height: div_height,
+            width: div_width,
+            require_start: require_start,
+            base_url_line: base_url_line,
+            script: script,
+            require_end: require_end
+          }
+          plotly_html_div.strip!
+
+          plotly_html_div
+        end
+
+        private def window_plotly_config
+          %Q(window.PlotlyConfig = {MathJaxConfig: 'local'};)
+        end
+
+        private def mathjax_config
+          %Q(if (window.MathJax) { MathJax.Hub.Config({SVG: {font: "STIX-Web"}}); })
+        end
+
+        private def get_plotlyjs
+          cache_path = CacheDir.path("plotly.min.js")
+          unless cache_path.exist?
+            download_plotlyjs(cache_path)
+          end
+          cache_path.read
+        end
+
+        private def download_plotlyjs(output_path)
+          downloader = Datasets::Downloader.new(PLOTLY_LATEST_CDN_URL)
+          downloader.download(output_path)
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/plotly_helpers/notebook_renderer.rb

@@ -0,0 +1,86 @@
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class NotebookRenderer < HtmlRenderer
+        def initialize(use_cdn: false)
+          super(use_cdn: use_cdn, full_html: false, requirejs: true)
+          @initialized = false
+        end
+
+        def activate()
+          return if @initialized
+
+          unless IRubyHelper.iruby_notebook?
+            raise "IRuby is unavailable"
+          end
+
+          if @use_cdn
+            script = <<~END_SCRIPT % {win_config: window_plotly_config, mathjax_config: mathjax_config}
+              <script type="text/javascript">
+                %{win_config}
+                %{mathjax_config}
+                if (typeof require !== 'undefined') {
+                  require.undef("plotly");
+                  requirejs.config({
+                    paths: {
+                      'plotly': ['https://cdn.plot.ly/plotly-latest.min']
+                    }
+                  });
+                  require(['plotly'], function (Plotly) {
+                    window._Plotly = Plotly;
+                  });
+                }
+              </script>
+            END_SCRIPT
+          else
+            script = <<~END_SCRIPT % {script: get_plotlyjs, win_config: window_plotly_config, mathjax_config: mathjax_config}
+              <script type="text/javascript">
+                %{win_config}
+                %{mathjax_config}
+                if (typeof require !== 'undefined') {
+                  require.undef("plotly");
+                  define('plotly', function (require, exports, module) {
+                    %{script}
+                  });
+                  require(['plotly'], function (Plotly) {
+                    window._Plotly = Plotly;
+                  });
+                }
+              </script>
+            END_SCRIPT
+          end
+        end
+
+        def render(figure, element_id: nil, post_script: nil)
+          ary = Array.try_convert(post_script)
+          post_script = ary || [post_script]
+          post_script.unshift(<<~END_POST_SCRIPT)
+            var gd = document.getElementById('%{plot_id}');
+            var x = new MutationObserver(function (mutations, observer) {
+              var display = window.getComputedStyle(gd).display;
+              if (!display || display === 'none') {
+                console.log([gd, 'removed']);
+                Plotly.purge(gd);
+                observer.disconnect();
+              }
+            });
+
+            // Listen for the removal of the full notebook cell
+            var notebookContainer = gd.closest('#notebook-container');
+            if (notebookContainer) {
+              x.observe(notebookContainer, {childList: true});
+            }
+
+            // Listen for the clearing of the current output cell
+            var outputEl = gd.closest('.output');
+            if (outputEl) {
+              x.observe(outputEl, {childList: true});
+            }
+          END_POST_SCRIPT
+
+          super(figure, element_id: element_id, post_script: post_script)
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/plotly_helpers/plotly_renderer.rb

@@ -0,0 +1,121 @@
+require "date"
+require "json"
+require "time"
+
+module Charty
+  module Backends
+    module PlotlyHelpers
+      class PlotlyRenderer
+        def render(figure)
+          json = JSON.generate(figure, allow_nan: true)
+          case json
+          when /\b(?:Infinity|NaN)\b/
+            visit(figure)
+          else
+            JSON.load(json)
+          end
+        end
+
+        private def visit(obj)
+          case obj
+          when Integer, String, Symbol, true, false, nil
+            obj
+
+          when Numeric
+            visit_float(obj)
+
+          when Time
+            visit_time(obj)
+
+          when Date
+            visit_date(obj)
+
+          when DateTime
+            visit_datetime(obj)
+
+          when Array
+            visit_array(obj)
+
+          when Hash
+            visit_hash(obj)
+
+          when ->(x) { defined?(Numo::NArray) && obj.is_a?(Numo::NArray) }
+            visit_array(obj.to_a)
+
+          when ->(x) { defined?(NMatrix) && obj.is_a?(NMatrix) }
+            visit_array(obj.to_a)
+
+          when ->(x) { defined?(Numpy::NDArray) && obj.is_a?(Numpy::NDArray) }
+            visit_array(obj.to_a)
+
+          when ->(x) { defined?(PyCall::List) && obj.is_a?(PyCall::List) }
+            visit_array(obj.to_a)
+
+          when ->(x) { defined?(PyCall::Tuple) && obj.is_a?(PyCall::Tuple) }
+            visit_array(obj.to_a)
+
+          when ->(x) { defined?(PyCall::Dict) && obj.is_a?(PyCall::Dict) }
+            visit_hash(obj.to_h)
+
+          when ->(x) { defined?(Pandas::Series) && obj.is_a?(Pandas::Series) }
+            visit_array(obj.to_a)
+
+          else
+            str = String.try_convert(obj)
+            return str unless str.nil?
+
+            ary = Array.try_convert(obj)
+            return visit_array(ary) unless ary.nil?
+
+            hsh = Hash.try_convert(obj)
+            return visit_hash(hsh) unless hsh.nil?
+
+            type_error(obj)
+          end
+        end
+
+        private def visit_float(obj)
+          obj = obj.to_f
+        rescue RangeError
+          type_error(obj)
+        else
+          case
+          when obj.finite?
+            obj
+          else
+            nil
+          end
+        end
+
+        private def visit_time(obj)
+          obj.iso8601(6)
+        end
+
+        private def visit_date(obj)
+          obj.iso8601(6)
+        end
+
+        private def visit_datetime(obj)
+          obj.iso8601(6)
+        end
+
+        private def visit_array(obj)
+          obj.map {|x| visit(x) }
+        end
+
+        private def visit_hash(obj)
+          obj.map { |key, value|
+            [
+              key,
+              visit(value)
+            ]
+          }.to_h
+        end
+
+        private def type_error(obj)
+          raise TypeError, "Unable to convert to JSON: %p" % obj
+        end
+      end
+    end
+  end
+end

data/lib/charty/backends/pyplot.rb

@@ -670,6 +670,7 @@ module Charty
 
       def render(notebook: false)
         show
+        nil
       end
 
       SAVEFIG_OPTIONAL_PARAMS = [

data/lib/charty/cache_dir.rb

@@ -0,0 +1,27 @@
+require "pathname"
+
+module Charty
+  module CacheDir
+    module_function
+
+    def cache_dir_path
+      platform_cache_dir_path + "charty"
+    end
+
+    def platform_cache_dir_path
+      base_dir = case RUBY_PLATFORM
+                 when /mswin/, /mingw/
+                   ENV.fetch("LOCALAPPDATA", "~/AppData/Local")
+                 when /darwin/
+                   "~/Library/Caches"
+                 else
+                   ENV.fetch("XDG_CACHE_HOME", "~/.cache")
+                 end
+      Pathname(base_dir).expand_path
+    end
+
+    def path(*path_components)
+      cache_dir_path.join(*path_components)
+    end
+  end
+end

data/lib/charty/iruby_helper.rb

@@ -0,0 +1,18 @@
+module Charty
+  module IRubyHelper
+    module_function
+
+    def iruby_notebook?
+      # TODO: This cannot distinguish notebook and console.
+      defined?(IRuby)
+    end
+
+    def vscode?
+      ENV.key?("VSCODE_PID")
+    end
+
+    def nteract?
+      ENV.key?("NTERACT_EXE")
+    end
+  end
+end

data/lib/charty/plot_methods.rb

@@ -248,6 +248,46 @@ module Charty
         &block
       )
     end
+
+    def hist_plot(data: nil, x: nil, y: nil, color: nil,
+                  stat: :count, bins: :auto,
+                  key_color: nil, palette: nil, color_order: nil, color_norm: nil,
+                  legend: true, **options, &block)
+      # TODO: support following arguments
+      # - wiehgts
+      # - binwidth
+      # - binrange
+      # - discrete
+      # - cumulative
+      # - common_bins
+      # - common_norm
+      # - multiple
+      # - element
+      # - fill
+      # - shrink
+      # - kde
+      # - kde_params
+      # - line_params
+      # - thresh
+      # - pthresh
+      # - pmax
+      # - cbar
+      # - cbar_params
+      # - x_log_scale
+      # - y_log_scale
+      Plotters::HistogramPlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color },
+        stat: stat,
+        bins: bins,
+        key_color: key_color,
+        palette: palette,
+        color_order: color_order,
+        color_norm: color_norm,
+        legend: legend,
+        **options,
+        &block)
+    end
   end
 
   extend PlotMethods

data/lib/charty/plotters.rb

@@ -10,3 +10,6 @@ require_relative "plotters/vector_plotter"
 require_relative "plotters/relational_plotter"
 require_relative "plotters/scatter_plotter"
 require_relative "plotters/line_plotter"
+
+require_relative "plotters/distribution_plotter"
+require_relative "plotters/histogram_plotter"

data/lib/charty/plotters/abstract_plotter.rb

@@ -183,7 +183,7 @@ module Charty
 
         levels = var_levels.dup
 
-        [:x, :y].each do |axis|
+        ([:x, :y] & grouping_vars).each do |axis|
           levels[axis] = plot_data[axis].categorical_order()
           if processed
             # TODO: perform inverse conversion of axis scaling here
@@ -213,16 +213,19 @@ module Charty
 
       def save(filename, **kwargs)
         backend = Backends.current
-        backend.begin_figure
-        render_plot(backend, **kwargs)
+        call_render_plot(backend, notebook: false, **kwargs)
         backend.save(filename, **kwargs)
       end
 
       def render(notebook: false, **kwargs)
         backend = Backends.current
+        call_render_plot(backend, notebook: notebook, **kwargs)
+        backend.render(notebook: notebook, **kwargs)
+      end
+
+      private def call_render_plot(backend, notebook: false, **kwargs)
         backend.begin_figure
         render_plot(backend, notebook: notebook, **kwargs)
-        backend.render(notebook: notebook, **kwargs)
       end
 
       private def render_plot(*, **)
@@ -231,12 +234,17 @@ module Charty
       end
 
       def to_iruby
-        render(notebook: iruby_notebook?)
+        render(notebook: IRubyHelper.iruby_notebook?)
       end
 
-      private def iruby_notebook?
-        return false unless defined?(IRuby)
-        true # TODO: Check the server is notebook or not
+      def to_iruby_mimebundle(include: [], exclude: [])
+        backend = Backends.current
+        if backend.respond_to?(:render_mimebundle)
+          call_render_plot(backend, notebook: true)
+          backend.render_mimebundle(include: include, exclude: exclude)
+        else
+          {}
+        end
       end
     end
   end

data/lib/charty/plotters/distribution_plotter.rb

@@ -0,0 +1,143 @@
+module Charty
+  module Plotters
+    class DistributionPlotter < AbstractPlotter
+      def flat_structure
+        {
+          x: :values
+        }
+      end
+
+      def initialize(data:, variables:, **options, &block)
+        x, y, color = variables.values_at(:x, :y, :color)
+        super(x, y, color, data: data, **options, &block)
+
+        setup_variables
+      end
+
+      attr_reader :variables
+
+      attr_reader :color_norm
+
+      def color_norm=(val)
+        unless val.nil?
+          raise NotImplementedError,
+                "Specifying color_norm is not supported yet"
+        end
+      end
+
+      attr_reader :legend
+
+      def legend=(val)
+        @legend = check_legend(val)
+      end
+
+      private def check_legend(val)
+        check_boolean(val, :legend)
+      end
+
+      attr_reader :input_format, :plot_data, :variables, :var_types
+
+      # This should be the same as one in RelationalPlotter
+      # TODO: move this to AbstractPlotter and refactor with CategoricalPlotter
+      private def setup_variables
+        if x.nil? && y.nil?
+          @input_format = :wide
+          setup_variables_with_wide_form_dataset
+        else
+          @input_format = :long
+          setup_variables_with_long_form_dataset
+        end
+
+        @var_types = @plot_data.columns.map { |k|
+          [k, variable_type(@plot_data[k], :categorical)]
+        }.to_h
+      end
+
+      private def setup_variables_with_wide_form_dataset
+        unless color.nil?
+          raise ArgumentError,
+                "Unable to assign the following variables in wide-form data: color"
+        end
+
+        if data.nil? || data.empty?
+          @plot_data = Charty::Table.new({})
+          @variables = {}
+          return
+        end
+
+        # TODO: detect flat data
+        flat = data.is_a?(Charty::Vector)
+        if flat
+          @plot_data = {}
+          @variables = {}
+
+          [:x, :y].each do |var|
+            case self.flat_structure[var]
+            when :index
+              @plot_data[var] = data.index.to_a
+              @variables[var] = data.index.name
+            when :values
+              @plot_data[var] = data.to_a
+              @variables[var] = data.name
+            end
+          end
+
+          @plot_data = Charty::Table.new(@plot_data)
+        else
+          raise NotImplementedError,
+                "wide-form input is not supported"
+        end
+      end
+
+      private def setup_variables_with_long_form_dataset
+        if data.nil? || data.empty?
+          @plot_data = Charty::Table.new({})
+          @variables = {}
+          return
+        end
+
+        plot_data = {}
+        variables = {}
+
+        {
+          x: self.x,
+          y: self.y,
+          color: self.color,
+        }.each do |key, val|
+          next if val.nil?
+
+          if data.column_names.include?(val)
+            plot_data[key] = data[val]
+            variables[key] = val
+          else
+            case val
+            when Charty::Vector
+              plot_data[key] = val
+              variables[key] = val.name
+            else
+              raise ArgumentError,
+                    "Could not interpret value %p for parameter %p" % [val, key]
+            end
+          end
+        end
+
+        @plot_data = Charty::Table.new(plot_data)
+        @variables = variables.select do |var, name|
+          @plot_data[var].notnull.any?
+        end
+      end
+
+      private def map_color(palette: nil, order: nil, norm: nil)
+        @color_mapper = ColorMapper.new(self, palette, order, norm)
+      end
+
+      private def map_size(sizes: nil, order: nil, norm: nil)
+        @size_mapper = SizeMapper.new(self, sizes, order, norm)
+      end
+
+      private def map_style(markers: nil, dashes: nil, order: nil)
+        @style_mapper = StyleMapper.new(self, markers, dashes, order)
+      end
+    end
+  end
+end

data/lib/charty/plotters/histogram_plotter.rb

@@ -0,0 +1,182 @@
+module Charty
+  module Plotters
+    class HistogramPlotter < DistributionPlotter
+      def univariate?
+        self.variables.key?(:x) != self.variables.key?(:y)
+      end
+
+      def univariate_variable
+        unless univariate?
+          raise TypeError, "This is not a univariate plot"
+        end
+        ([:x, :y] & self.variables.keys)[0]
+      end
+
+      attr_reader :weights
+
+      def weights=(val)
+        @weights = check_weights(val)
+      end
+
+      private def check_weights(val)
+        raise NotImplementedError, "weights is not supported yet"
+      end
+
+      attr_reader :stat
+
+      def stat=(val)
+        @stat = check_stat(val)
+      end
+
+      private def check_stat(val)
+        case val
+        when :count, "count"
+          val.to_sym
+        when :frequency, "frequency",
+             :density, "density",
+             :probability, "probability"
+          raise ArgumentError,
+                "%p for `stat` is not supported yet" % val,
+                caller
+        else
+          raise ArgumentError,
+                "Invalid value for `stat` (%p)" % val,
+                caller
+        end
+      end
+
+      attr_reader :bins
+
+      def bins=(val)
+        @bins = check_bins(val)
+      end
+
+      private def check_bins(val)
+        case val
+        when :auto, "auto"
+          val.to_sym
+        when Integer
+          val
+        else
+          raise ArgumentError,
+                "Invalid value for `bins` (%p)" % val,
+                caller
+        end
+      end
+
+      # TODO: bin_width
+      # TODO: bin_range
+      # TODO: discrete
+      # TODO: cumulative
+      # TODO: common_bins
+      # TODO: common_norm
+
+      attr_reader :multiple
+
+      def multiple=(val)
+        @multiple = check_multiple(val)
+      end
+
+      private def check_multiple(val)
+        case val
+        when :layer, "layer"
+          val.to_sym
+        when :dodge, "dodge",
+             :stack, "stack",
+             :fill, "fill"
+          val = val.to_sym
+          raise NotImplementedError,
+                "%p for `multiple` is not supported yet" % val,
+                caller
+        else
+          raise ArgumentError,
+                "Invalid value for `multiple` (%p)" % val,
+                caller
+        end
+      end
+
+      # TODO: element
+      # TODO: fill
+      # TODO: shrink
+
+      attr_reader :kde
+
+      def kde=(val)
+        raise NotImplementedError, "kde is not supported yet"
+      end
+
+      attr_reader :kde_params
+
+      def kde_params=(val)
+        raise NotImplementedError, "kde_params is not supported yet"
+      end
+
+      # TODO: thresh
+      # TODO: pthresh
+      # TODO: pmax
+      # TODO: cbar
+      # TODO: cbar_params
+      # TODO: x_log_scale
+      # TODO: y_log_scale
+
+      private def render_plot(backend, **)
+        draw_univariate_histogram(backend)
+        annotate_axes(backend)
+      end
+
+      private def draw_univariate_histogram(backend)
+        map_color(palette: palette, order: color_order, norm: color_norm)
+
+        # TODO: calculate histogram here and use bar plot to visualize
+        data_variable = self.univariate_variable
+
+        histograms = {}
+        each_subset([:color], processed: true) do |sub_vars, sub_data|
+          key = sub_vars.to_a
+          observations = sub_data[data_variable].drop_na.to_a
+          hist = Statistics.histogram(observations)
+          histograms[key] = hist
+        end
+
+        bin_start, bin_end, bin_size = nil
+        histograms.each do |_, hist|
+          s, e = hist.edge.minmax
+          z = (e - s).to_f / (hist.edge.length - 1)
+          bin_start = [bin_start, s].compact.min
+          bin_end   = [bin_end, e].compact.max
+          bin_size  = [bin_size, z].compact.min
+        end
+
+        if self.variables.key?(:color)
+          alpha = 0.5
+        else
+          alpha = 0.75
+        end
+
+        each_subset([:color], processed: true) do |sub_vars, sub_data|
+          name = sub_vars[:color]
+          observations = sub_data[data_variable].drop_na.to_a
+
+          backend.univariate_histogram(observations, name, data_variable, stat,
+                                       bin_start, bin_end, bin_size, alpha,
+                                       name, @color_mapper)
+        end
+      end
+
+      private def annotate_axes(backend)
+        if univariate?
+          xlabel = self.variables[:x]
+          ylabel = self.variables[:y]
+          case self.univariate_variable
+          when :x
+            ylabel = self.stat.to_s.capitalize
+          else
+            xlabel = self.stat.to_s.capitalize
+          end
+          backend.set_ylabel(ylabel) if ylabel
+          backend.set_xlabel(xlabel) if xlabel
+        end
+      end
+    end
+  end
+end

data/lib/charty/statistics.rb

@@ -10,6 +10,10 @@ module Charty
       def self.stdev(enum, population: false)
         enum.stdev(population: population)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        ary.histogram(*args, **kwargs)
+      end
     rescue LoadError
       def self.mean(enum)
         xs = enum.to_a
@@ -24,6 +28,11 @@ module Charty
         var = xs.map {|x| (x - mean)**2 }.sum / (n - ddof)
         Math.sqrt(var)
       end
+
+      def self.histogram(ary, *args, **kwargs)
+        raise NotImplementedError,
+              "histogram is currently supported only with enumerable-statistics"
+      end
     end
 
     def self.bootstrap(vector, n_boot: 2000, func: :mean, units: nil, random: nil)

data/lib/charty/version.rb

@@ -1,5 +1,5 @@
 module Charty
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 
   module Version
     numbers, TAG = VERSION.split("-")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: charty
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - youchan
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-06-17 00:00:00.000000000 Z
+date: 2021-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: red-colors
@@ -26,6 +26,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: red-datasets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: red-palette
   requirement: !ruby/object:Gem::Requirement
@@ -124,20 +138,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: red-datasets
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.2
 - !ruby/object:Gem::Dependency
   name: daru
   requirement: !ruby/object:Gem::Requirement
@@ -287,11 +287,16 @@ files:
 - lib/charty/backends/google_charts.rb
 - lib/charty/backends/gruff.rb
 - lib/charty/backends/plotly.rb
+- lib/charty/backends/plotly_helpers/html_renderer.rb
+- lib/charty/backends/plotly_helpers/notebook_renderer.rb
+- lib/charty/backends/plotly_helpers/plotly_renderer.rb
 - lib/charty/backends/pyplot.rb
 - lib/charty/backends/rubyplot.rb
 - lib/charty/backends/unicode_plot.rb
+- lib/charty/cache_dir.rb
 - lib/charty/dash_pattern_generator.rb
 - lib/charty/index.rb
+- lib/charty/iruby_helper.rb
 - lib/charty/layout.rb
 - lib/charty/linspace.rb
 - lib/charty/plot_methods.rb
@@ -302,7 +307,9 @@ files:
 - lib/charty/plotters/box_plotter.rb
 - lib/charty/plotters/categorical_plotter.rb
 - lib/charty/plotters/count_plotter.rb
+- lib/charty/plotters/distribution_plotter.rb
 - lib/charty/plotters/estimation_support.rb
+- lib/charty/plotters/histogram_plotter.rb
 - lib/charty/plotters/line_plotter.rb
 - lib/charty/plotters/random_support.rb
 - lib/charty/plotters/relational_plotter.rb