charty 0.2.4 → 0.2.9

data/lib/charty/backends/rubyplot.rb

@@ -33,7 +33,7 @@ module Charty
         @plot.show
       end
 
-      def render(context, filename="")
+      def old_style_render(context, filename="")
         FileUtils.mkdir_p(File.dirname(filename))
         plot(@plot, context).write(filename)
       end

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/dash_pattern_generator.rb

@@ -0,0 +1,57 @@
+module Charty
+  module DashPatternGenerator
+    NAMED_PATTERNS = {
+            solid: "",
+             dash: [4, 1.5],
+              dot:  [1, 1],
+          dashdot: [3, 1.25, 1.5, 1.25],
+      longdashdot: [5, 1, 1, 1],
+    }.freeze
+
+    def self.valid_name?(name)
+      name = case name
+             when Symbol, String
+               name.to_sym
+             else
+               name.to_str.to_sym
+             end
+      NAMED_PATTERNS.key?(name)
+    end
+
+    def self.pattern_to_name(pattern)
+      NAMED_PATTERNS.each do |key, val|
+        return key if pattern == val
+      end
+      nil
+    end
+
+    def self.each
+      return enum_for(__method__) unless block_given?
+
+      NAMED_PATTERNS.each_value do |pattern|
+        yield pattern
+      end
+
+      m = 3
+      while true
+        # Long and short dash combinations
+        a = [3, 1.25].repeated_combination(m).to_a[1..-2].reverse
+        b = [4, 1].repeated_combination(m).to_a[1..-2]
+
+        # Interleave these combinations
+        segment_list = a.zip(b).flatten(1)
+
+        # Insert the gaps
+        segment_list.each do |segment|
+          gap = segment.min
+          pattern = segment.map {|seg| [seg, gap] }.flatten
+          yield pattern
+        end
+
+        m += 1
+      end
+    end
+
+    extend Enumerable
+  end
+end

data/lib/charty/index.rb

@@ -49,7 +49,7 @@ module Charty
         return index.union(other) if index
       end
 
-      Index.new(to_a.union(other.to_a))
+      Index.new(to_a.union(other.to_a), name: name)
     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

@@ -130,6 +130,76 @@ module Charty
       )
     end
 
+    # Line plot
+    #
+    # @param x [vector-like object, key in data]
+    # @param y [vector-like object, key in data]
+    # @param color [vector-like object, key in data]
+    # @param style [vector-like object, key in data]
+    # @param size [vector-like object, key in data]
+    # @param data [table-like object]
+    # @param key_color [color object]
+    # @param palette [String,Array<Numeric>,Palette]
+    # @param color_order [Array<String>,Array<Symbol>]
+    # @param color_norm
+    # @param sizes [Array, Hash]
+    # @param size_order [Array]
+    # @param size_norm
+    # @param dashes [true, false, Array, Hash]
+    # @param markers [true, false, Array, Hash]
+    # @param style_order [Array]
+    # @param units [vector-like object, key in data]
+    # @param estimator [:mean]
+    # @param n_boot [Integer]
+    # @param random [Integer, Random, nil]
+    # @param sort [true, false]
+    # @param err_style [:band, :bars]
+    # @param err_params [Hash]
+    # @param error_bar
+    # @param x_scale [:linear, :log10]
+    # @param y_scale [:linear, :log10]
+    # @param legend [:auto, :brief, :full, false]
+    #        How to draw legend.  If :brief, numeric color and size variables
+    #        will be represented with a sample of evenly spaced values.  If
+    #        :full, every group will get an entry in the legend.  If :auto,
+    #        choose between brief or full representation based on number of
+    #        levels.  If false, no legend data is added and no legend is drawn.
+    def line_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
+                  data: nil, key_color: nil, palette: nil, color_order: nil,
+                  color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
+                  markers: nil, dashes: true, style_order: nil,
+                  units: nil, estimator: :mean, n_boot: 1000, random: nil,
+                  sort: true, err_style: :band, err_params: nil, error_bar: [:ci, 95],
+                  x_scale: :linear, y_scale: :linear, legend: :auto, **options, &block)
+      Plotters::LinePlotter.new(
+        data: data,
+        variables: { x: x, y: y, color: color, style: style, size: size },
+        key_color: key_color,
+        palette: palette,
+        color_order: color_order,
+        color_norm: color_norm,
+        sizes: sizes,
+        size_order: size_order,
+        size_norm: size_norm,
+        markers: markers,
+        dashes: dashes,
+        style_order: style_order,
+        units: units,
+        estimator: estimator,
+        n_boot: n_boot,
+        random: random,
+        sort: sort,
+        err_style: err_style,
+        err_params: err_params,
+        error_bar: error_bar,
+        x_scale: x_scale,
+        y_scale: y_scale,
+        legend: legend,
+        **options,
+        &block
+      )
+    end
+
     # Scatter plot
     #
     # @param x [vector-like object, key in data]
@@ -146,7 +216,7 @@ module Charty
     # @param size_order [Array]
     # @param size_norm
     # @param markers [true, false, Array, Hash]
-    # @param marker_order [Array]
+    # @param style_order [Array]
     # @param alpha [scalar number]
     #        Propotional opacity of the points.
     # @param legend [:auto, :brief, :full, false]
@@ -158,7 +228,7 @@ module Charty
     def scatter_plot(x: nil, y: nil, color: nil, style: nil, size: nil,
                      data: nil, key_color: nil, palette: nil, color_order: nil,
                      color_norm: nil, sizes: nil, size_order: nil, size_norm: nil,
-                     markers: true, marker_order: nil, alpha: nil, legend: :auto,
+                     markers: true, style_order: nil, alpha: nil, legend: :auto,
                      **options, &block)
       Plotters::ScatterPlotter.new(
         data: data,
@@ -171,13 +241,55 @@ module Charty
         size_order: size_order,
         size_norm: size_norm,
         markers: markers,
-        marker_order: marker_order,
+        style_order: style_order,
         alpha: alpha,
         legend: legend,
         **options,
         &block
       )
     end
+
+    def hist_plot(data: nil, x: nil, y: nil, color: nil, weights: nil,
+                  stat: :count, bins: :auto,
+                  bin_range: nil, common_bins: true,
+                  key_color: nil, palette: nil, color_order: nil, color_norm: nil,
+                  legend: true, **options, &block)
+      # TODO: support following arguments
+      # - wiehgts
+      # - binwidth
+      # - discrete
+      # - cumulative
+      # - 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 },
+        weights: weights,
+        stat: stat,
+        bins: bins,
+        bin_range: bin_range,
+        common_bins: common_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/plotter.rb

@@ -237,11 +237,11 @@ module Charty
     end
 
     def render(filename=nil)
-      @backend.render(self, filename)
+      @backend.old_style_render(self, filename)
     end
 
     def save(filename=nil, **kw)
-      @backend.save(self, filename, **kw)
+      @backend.old_style_save(self, filename, **kw)
     end
 
     def apply(backend)

data/lib/charty/plotters.rb

@@ -9,3 +9,7 @@ require_relative "plotters/count_plotter"
 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

@@ -8,16 +8,38 @@ module Charty
         self.data = data
         self.palette = palette
         substitute_options(options)
+
+        @var_levels = {}
+        @var_ordered = {x: false, y: false}
+
         yield self if block_given?
       end
 
       attr_reader :data, :x, :y, :color
       attr_reader :color_order, :key_color, :palette
 
+      def var_levels
+        variables.each_key do |var|
+          # TODO: Move mappers from RelationalPlotter to here,
+          #       and remove the use of instance_variable_get
+          if instance_variable_defined?(:"@#{var}_mapper")
+            mapper = instance_variable_get(:"@#{var}_mapper")
+            @var_levels[var] = mapper.levels
+          end
+        end
+        @var_levels
+      end
+
+      def inspect
+        "#<#{self.class}:0x%016x>" % self.object_id
+      end
+
       def data=(data)
         @data = case data
                 when nil, Charty::Table
                   data
+                when method(:array?)
+                  Charty::Vector.new(data)
                 else
                   Charty::Table.new(data)
                 end
@@ -36,11 +58,7 @@ module Charty
       end
 
       def color_order=(color_order)
-        #@color_order = XXX
-        unless color_order.nil?
-          raise NotImplementedError,
-                "Specifying color_order is not supported yet"
-        end
+        @color_order = color_order
       end
 
       # TODO: move to categorical_plotter
@@ -140,16 +158,93 @@ module Charty
       end
 
       private def remove_na!(ary)
-        ary.reject! do |x|
-          next true if x.nil?
-          x.respond_to?(:nan?) && x.nan?
-        end
+        ary.reject! {|x| Util.missing?(x) }
         ary
       end
 
+      private def each_subset(grouping_vars, reverse: false, processed: false, by_facet: true, allow_empty: false, drop_na: true)
+        case grouping_vars
+        when nil
+          grouping_vars = []
+        when String, Symbol
+          grouping_vars = [grouping_vars.to_sym]
+        end
+
+        if by_facet
+          [:col, :row].each do |facet_var|
+            grouping_vars << facet_var if variables.key?(facet_var)
+          end
+        end
+
+        grouping_vars = grouping_vars.select {|var| variables.key?(var) }
+
+        data = processed ? processed_data : plot_data
+        data = data.drop_na if drop_na
+
+        levels = var_levels.dup
+
+        ([:x, :y] & grouping_vars).each do |axis|
+          levels[axis] = plot_data[axis].categorical_order()
+          if processed
+            # TODO: perform inverse conversion of axis scaling here
+          end
+        end
+
+        if not grouping_vars.empty?
+          grouped = data.group_by(grouping_vars, sort: false)
+          grouped.each_group do |group_key, group_data|
+            next if group_data.empty? && !allow_empty
+
+            yield(grouping_vars.zip(group_key).to_h, group_data)
+          end
+        else
+          yield({}, data.dup)
+        end
+      end
+
+      def processed_data
+        @processed_data ||= calculate_processed_data
+      end
+
+      private def calculate_processed_data
+        # TODO: axis scaling support
+        plot_data
+      end
+
+      def save(filename, **kwargs)
+        backend = Backends.current
+        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)
+      end
+
+      private def render_plot(*, **)
+        raise NotImplementedError,
+              "subclass must implement #{__method__}"
+      end
+
       def to_iruby
-        result = render
-        ["text/html", result] if result
+        render(notebook: IRubyHelper.iruby_notebook?)
+      end
+
+      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