rails-data-explorer 0.0.1

data/lib/rails-data-explorer/chart/scatterplot.rb

@@ -0,0 +1,120 @@
+class RailsDataExplorer
+  class Chart
+    class Scatterplot < Chart
+
+      def initialize(_data_set, options = {})
+        @data_set = _data_set
+        @options = {}.merge(options)
+      end
+
+      def compute_chart_attrs
+        x_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::Scatterplot] & [:x, :any]).any?
+        }
+        y_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::Scatterplot] & [:y, :any]).any?
+        }
+        color_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::Scatterplot] & [:color, :any]).any?
+        }
+        size_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::Scatterplot] & [:size, :any]).any?
+        }
+
+        x_ds = x_candidates.first
+        y_ds = (y_candidates - [x_ds]).first
+        color_ds = (color_candidates - [x_ds, y_ds]).first
+        size_ds = (size_candidates - [x_ds, y_ds, color_ds]).first
+
+        ca = case @data_set.dimensions_count
+        when 0,1
+          raise(ArgumentError.new("At least two data series required for scatterplot, only #{ @data_set.dimensions_count } given"))
+        when 2
+          key = ''
+          values_hash = x_ds.values.length.times.map { |idx|
+            r = { x: x_ds.values[idx], y: y_ds.values[idx] }
+            r[:color] = color_ds.values[idx]  if color_ds
+            r
+          }
+          {
+            values: [ { key: key, values: values_hash } ],
+            x_axis_label: x_ds.name,
+            x_axis_tick_format: x_ds.axis_tick_format,
+            y_axis_label: y_ds.name,
+            y_axis_tick_format: y_ds.axis_tick_format,
+          }
+        when 3
+          visual_attr_ds = color_ds || size_ds
+          raise "No visual_attr_ds given"  if visual_attr_ds.nil?
+          data_series_hash = visual_attr_ds.values.uniq.inject({}) { |m,visual_attr|
+            m[visual_attr] = []
+            m
+          }
+          x_ds.values.length.times.each { |idx|
+            data_series_hash[visual_attr_ds.values[idx]] << { x: x_ds.values[idx], y: y_ds.values[idx] }
+          }
+          {
+            values: data_series_hash.map { |k,v| { key: k, values: v } },
+            x_axis_label: x_ds.name,
+            x_axis_tick_format: x_ds.axis_tick_format,
+            y_axis_label: y_ds.name,
+            y_axis_tick_format: y_ds.axis_tick_format,
+          }
+        else
+        end
+        ca
+      end
+
+      def render
+        return ''  unless render?
+        chart_attrs = compute_chart_attrs
+        %(
+          <div class="rde-chart rde-scatterplot">
+            <h3 class="rde-chart-title">Scatterplot</h3>
+            <div id="#{ dom_id }", style="height: 400px;">
+              <svg></svg>
+            </div>
+            <script type="text/javascript">
+              (function() {
+                var data = #{ chart_attrs[:values].to_json };
+
+                nv.addGraph(function() {
+                  var chart = nv.models.scatterChart()
+                                .showDistX(true)
+                                .showDistY(true)
+                                .useVoronoi(true)
+                                .color(d3.scale.category10().range())
+                                .transitionDuration(300)
+                                ;
+
+                  chart.xAxis.tickFormat(#{ chart_attrs[:x_axis_tick_format] })
+                             .axisLabel('#{ chart_attrs[:x_axis_label] }')
+                             ;
+
+                  chart.yAxis.tickFormat(#{ chart_attrs[:y_axis_tick_format] })
+                             .axisLabel('#{ chart_attrs[:y_axis_label] }')
+                             ;
+
+                  chart.tooltipContent(function(key) {
+                      return key;
+                  });
+
+                  d3.select('##{ dom_id } svg')
+                      .datum(data)
+                      .call(chart);
+
+                  nv.utils.windowResize(chart.update);
+
+                  chart.dispatch.on('stateChange', function(e) { ('New State:', JSON.stringify(e)); });
+
+                  return chart;
+                });
+              })();
+            </script>
+          </div>
+        )
+      end
+
+    end
+  end
+end

data/lib/rails-data-explorer/chart/scatterplot_matrix.rb

@@ -0,0 +1 @@
+# http://benjiec.github.io/scatter-matrix/demo/demo.html#

data/lib/rails-data-explorer/chart/stacked_bar_chart_categorical_percent.rb

@@ -0,0 +1,120 @@
+class RailsDataExplorer
+  class Chart
+    class StackedBarChartCategoricalPercent < Chart
+
+      def initialize(_data_set, options = {})
+        @data_set = _data_set
+        @options = {}.merge(options)
+      end
+
+      def compute_chart_attrs
+        x_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::ContingencyTable] & [:x, :any]).any?
+        }.sort { |a,b| b.uniq_vals.length <=> a.uniq_vals.length }
+        y_candidates = @data_set.data_series.find_all { |ds|
+          (ds.chart_roles[Chart::ContingencyTable] & [:y, :any]).any?
+        }
+
+        x_ds = x_candidates.first
+        y_ds = (y_candidates - [x_ds]).first
+
+        # initialize data_matrix
+        data_matrix = { :_sum => { :_sum => 0 } }
+        x_ds.uniq_vals.each { |x_val|
+          data_matrix[x_val] = {}
+          data_matrix[x_val][:_sum] = 0
+          y_ds.uniq_vals.each { |y_val|
+            data_matrix[x_val][y_val] = 0
+            data_matrix[:_sum][y_val] = 0
+          }
+        }
+        # populate data_matrix
+        x_ds.values.length.times { |idx|
+          x_val = x_ds.values[idx]
+          y_val = y_ds.values[idx]
+          data_matrix[x_val][y_val] += 1
+          data_matrix[:_sum][y_val] += 1
+          data_matrix[x_val][:_sum] += 1
+          data_matrix[:_sum][:_sum] += 1
+        }
+
+        x_sorted_keys = x_ds.uniq_vals.sort { |a,b|
+          data_matrix[b][:_sum] <=> data_matrix[a][:_sum]
+        }
+        y_sorted_keys = y_ds.uniq_vals.sort { |a,b|
+          data_matrix[:_sum][b] <=> data_matrix[:_sum][a]
+        }
+
+        values = case @data_set.dimensions_count
+        when 2
+          y_sorted_keys.map { |y_val|
+            {
+              key: y_val,
+              values: x_sorted_keys.map { |x_val|
+                {
+                  x: x_val,
+                  y: (data_matrix[x_val][y_val] / data_matrix[x_val][:_sum].to_f) }
+              }
+            }
+          }
+        else
+          raise(ArgumentError.new("Exactly two data series required for contingency table."))
+        end
+        {
+          values: values,
+          x_axis_label: x_ds.name,
+          x_axis_tick_format: 'function(d) { return d }',
+          y_axis_label: "#{ y_ds.name } distribution [%]",
+          y_axis_tick_format: "d3.format('.1%')",
+        }
+      end
+
+      def render
+        return ''  unless render?
+        ca = compute_chart_attrs
+        %(
+          <div class="rde-chart rde-bar-chart">
+            <h3 class="rde-chart-title">Stacked Bar Chart</h3>
+            <div id="#{ dom_id }", style="height: 200px;">
+              <svg></svg>
+            </div>
+            <script type="text/javascript">
+              (function() {
+                var data = #{ ca[:values].to_json };
+
+                nv.addGraph(function() {
+                  var chart = nv.models.multiBarChart()
+                    ;
+
+                  chart.xAxis
+                    .axisLabel('#{ ca[:x_axis_label] }')
+                    .tickFormat(#{ ca[:x_axis_tick_format] })
+                    ;
+
+                  chart.yAxis
+                    .axisLabel('#{ ca[:y_axis_label] }')
+                    .tickFormat(#{ ca[:y_axis_tick_format] })
+                    ;
+
+                  chart.multibar.stacked(true);
+                  chart.showControls(false);
+
+                  d3.select('##{ dom_id } svg')
+                    .datum(data)
+                    .transition().duration(100)
+                    .call(chart)
+                    ;
+
+                  nv.utils.windowResize(chart.update);
+
+                  return chart;
+                });
+              })();
+            </script>
+          </div>
+        )
+      end
+
+    end
+  end
+end

data/lib/rails-data-explorer/data_series.rb

@@ -0,0 +1,115 @@
+class RailsDataExplorer
+  class DataSeries
+
+    # TODO: Add concept of significant figures for rounding values when displaying them
+    # http://en.wikipedia.org/wiki/Significant_figures
+
+    attr_reader :data_type, :name, :values, :chart_roles
+    delegate :available_chart_types, :to => :data_type, :prefix => false
+    delegate :available_chart_roles, :to => :data_type, :prefix => false
+
+    # options: :chart_roles, :data_type (all optional)
+    def initialize(_name, _values, options={})
+      options = { chart_roles: [], data_type: nil }.merge(options)
+      @name = _name
+      @values = _values
+      @data_type = init_data_type(options[:data_type])
+      @chart_roles = init_chart_roles(options[:chart_roles]) # after data_type!
+    end
+
+    # Returns descriptive_statistics as a flat Array
+    def descriptive_statistics
+      @data_type.descriptive_statistics(values)
+    end
+
+    # Returns descriptive_statistics as a renderable table structure
+    def descriptive_statistics_table
+      @data_type.descriptive_statistics_table(values)
+    end
+
+    def values_summary
+      if values.length < 3 || values.inspect.length < 80
+        values.inspect
+      else
+        "[#{ values.first } ... #{ values.last }]"
+      end
+    end
+
+    def inspect(indent=1, recursive=1000)
+      r = %(#<#{ self.class.to_s }\n)
+      r << [
+        "@name=#{ name.inspect }",
+        "@data_type=#{ data_type.inspect }",
+        "@chart_roles=#{ chart_roles.inspect }",
+        "@values=<count: #{ values.count }, items: #{ values_summary }>",
+      ].map { |e| "#{ '  ' * indent }#{ e }\n"}.join
+      if recursive > 0
+        # nothing to recurse
+      end
+      r << %(#{ '  ' * (indent-1) }>\n)
+    end
+
+    def axis_tick_format
+      data_type.axis_tick_format(values)
+    end
+
+    def uniq_vals
+      @uniq_vals = values.uniq
+    end
+
+    def uniq_vals_count
+      @uniq_vals_count = uniq_vals.length
+    end
+
+    def min_val
+      @min_val = values.compact.min
+    end
+
+    def max_val
+      @max_val = values.compact.max
+    end
+
+  private
+
+    # @param[Array<Symbol>] chart_role_overrides, :x, :y, :color
+    # @return[Hash] keys are chart_classes, and values are arrays with roles
+    def init_chart_roles(chart_role_overrides)
+      r = if chart_role_overrides.any?
+        available_chart_types.inject(Hash.new([])) { |m,chart_type|
+          subset = chart_type[:chart_roles] & chart_role_overrides
+          next m if subset.empty?
+          m[chart_type[:chart_class]] += subset
+          m[chart_type[:chart_class]].uniq!
+          m
+        }
+      else
+        available_chart_types.inject(Hash.new([])) { |m,chart_type|
+          m[chart_type[:chart_class]] += chart_type[:chart_roles]
+          m[chart_type[:chart_class]].uniq!
+          m
+        }
+      end
+      r.freeze
+    end
+
+    def init_data_type(data_type_override)
+      if data_type_override.nil?
+        case values.first
+        when Integer, Bignum, Fixnum
+          DataType::Quantitative::Integer.new
+        when Float
+          DataType::Quantitative::Decimal.new
+        when String
+          DataType::Categorical.new
+        when DateTime, ActiveSupport::TimeWithZone
+          DataType::Quantitative::Temporal.new
+        else
+          raise(ArgumentError.new("Can't infer data type for value: #{ values.first.class.inspect }"))
+        end
+      else
+        data_type_override
+      end
+    end
+
+  end
+end

data/lib/rails-data-explorer/data_set.rb

@@ -0,0 +1,127 @@
+# Container for data series
+class RailsDataExplorer
+  class DataSet
+
+    attr_reader :data_series
+
+    # @param[Array<Numeric, String, Symbol, Nil, Hash, DataSeries>] values_or_data_series
+    #  Array can contain the following:
+    #  * Numeric, String, Symbol, Nil - for a single data series
+    #  * Hash - for multiple data series with the following keys:
+    #    * :name - name for the series as String
+    #    * :values - scalar values as array
+    #    * :chart_roles [Array<Symbol>, optional] - what to use this series for. possible values: :x, :y, :color
+    #    * :data_type (optional) - :quantitative, :categorical, :temporal
+    #  * DataSeries
+    # @param[String] exploration_title used as fall back for data series name
+    def initialize(values_or_data_series, exploration_title)
+      @data_series = initialize_data_series(values_or_data_series, exploration_title)
+      validate_data_series
+    end
+
+    def initialize_data_series(values_or_data_series, exploration_title)
+      case values_or_data_series.first
+      when ActiveSupport::TimeWithZone, DateTime, Numeric, NilClass, String, Symbol
+        # Array of scalar values, convert to single data series
+        [DataSeries.new(exploration_title, values_or_data_series)]
+      when Hash
+        # Array of Hashes, convert each key/val pair to a data series
+        values_or_data_series.map { |data_series_attrs|
+          DataSeries.new(
+            data_series_attrs.delete(:name),
+            data_series_attrs.delete(:values),
+            data_series_attrs # pass remaining attrs as options
+          )
+        }
+      when DataSeries
+        # return as is
+        values_or_data_series
+      else
+        raise(
+          ArgumentError.new(
+            "Invalid datum. Only Hash, Numeric, String, Symbol, and Nil are allowed. " + \
+            "Found #{ values_or_data_series.first.class.to_s }."
+          )
+        )
+      end
+    end
+
+    def validate_data_series
+      # all series have same size
+      unless 1 == @data_series.map { |e| e.values.length }.uniq.length
+        raise(ArgumentError.new("All data series must have same length."))
+      end
+      # presence of at least one data_series
+      if 0 == dimensions_count
+        raise(ArgumentError.new("Please provide at least 1 data series."))
+      end
+      # TODO: all elements in a series are of same type
+    end
+
+    def dimensions_count
+      @data_series.length
+    end
+
+    def available_chart_types
+      case dimensions_count
+      when 0
+        # invalid, handled in validate_data_series
+      when 1
+        # charts for a single data series, use that series' available_chart_types
+        @data_series.first.available_chart_types(dimensions_count: 1).map { |e| e[:chart_class] }
+      else
+        # TODO: define on each chart type which chart_roles are required.
+        # Then use only charts for which all roles are filled.
+        # charts for two data series
+        # find intersection of all available chart types
+        r = @data_series.inject(nil) { |m,ds|
+          constraints = { dimensions_count: dimensions_count, chart_roles: ds.chart_roles }
+          # initialize m with first data series
+          m = ds.available_chart_types(constraints).map { |e| e[:chart_class] }  if m.nil?
+          # find intersection of all available_chart_types
+          m = ds.available_chart_types(constraints).map { |e| e[:chart_class] } & m
+          m
+        }
+        r
+      end
+    end
+
+    def descriptive_statistics
+      case dimensions_count
+      when 0
+        # invalid, handled in validate_data_series
+      when 1
+        # charts for a single data series, use that series' descriptive_statistics
+        @data_series.first.descriptive_statistics
+      when 2
+        # charts for two data series
+      else
+        # charts for multiple data series
+      end
+    end
+
+    def inspect(indent=1, recursive=1000)
+      r = %(#<#{ self.class.to_s }\n)
+      r << [
+        "@dimensions_count=#{ dimensions_count }",
+      ].map { |e| "#{ '  ' * indent }#{ e }\n"}.join
+      if recursive > 0
+        # data_series
+        r << %(#{ '  ' * indent }@data_series=[\n)
+        data_series.each do |e|
+          r << "#{ '  ' * (indent + 1) }"
+          r << e.inspect(indent + 2, recursive - 1)
+        end
+        r << "#{ '  ' * indent }]\n"
+        # available_chart_types
+        r << %(#{ '  ' * indent }@available_chart_types=[\n)
+        available_chart_types.each do |e|
+          r << "#{ '  ' * (indent + 1) }#{ e.inspect }\n"
+        end
+        r << "#{ '  ' * indent }]\n"
+      end
+      r << %(#{ '  ' * (indent-1) }>\n)
+    end
+
+  end
+end