rails-data-explorer 0.0.1

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

@@ -0,0 +1,34 @@
+class RailsDataExplorer
+  class DataType
+
+    # @param[Hash, optional] constraints
+    #  * :dimensions_count - how many data_series are there?
+    def available_chart_types(constraints={})
+      r = all_available_chart_types
+      if(c = constraints.delete(:dimensions_count))
+        r = r.find_all { |chart_type|
+          (
+            chart_type[:dimensions_count_min].nil? ||
+            (chart_type[:dimensions_count_min] <= c)
+          ) && (
+            chart_type[:dimensions_count_max].nil? ||
+            (chart_type[:dimensions_count_max] >= c)
+          )
+        }
+      end
+      if(c = constraints.delete(:chart_roles))
+        # c = { ChartClass => [:x, :y], ... }
+        r = r.find_all { |chart_type|
+          c[chart_type[:chart_class]].nil? ||
+          (c[chart_type[:chart_class]] & chart_type[:chart_roles]).any?
+        }
+      end
+      # check for any unhandled options
+      if constraints.any?
+        raise "Unhandled constraints: #{ constraints.inspect }"
+      end
+      r
+    end
+
+  end
+end

data/lib/rails-data-explorer/data_type/categorical.rb

@@ -0,0 +1,117 @@
+class RailsDataExplorer
+  class DataType
+    class Categorical < DataType
+
+      def all_available_chart_types
+        [
+          {
+            :chart_class => Chart::HistogramCategorical,
+            :chart_roles => [:x],
+            :dimensions_count_min => 1,
+            :dimensions_count_max => 1,
+          },
+          {
+            :chart_class => Chart::PieChart,
+            :chart_roles => [:any],
+            :dimensions_count_min => 1,
+            :dimensions_count_max => 1,
+          },
+          {
+            chart_class: Chart::BoxPlotGroup,
+            chart_roles: [:y],
+            dimensions_count_min: 2,
+            dimensions_count_max: 2,
+          },
+          {
+            chart_class: Chart::Scatterplot,
+            chart_roles: [:color],
+            dimensions_count_min: 3,
+          },
+          {
+            chart_class: Chart::ParallelCoordinates,
+            chart_roles: [:dimension],
+            dimensions_count_min: 3,
+          },
+          {
+            chart_class: Chart::StackedBarChartCategoricalPercent,
+            chart_roles: [:x, :y],
+            dimensions_count_min: 2,
+            dimensions_count_max: 2,
+          },
+          {
+            chart_class: Chart::ContingencyTable,
+            chart_roles: [:any],
+            dimensions_count_min: 2,
+            dimensions_count_max: 2,
+          },
+          {
+            chart_class: Chart::DescriptiveStatisticsTable,
+            chart_roles: [:any],
+            dimensions_count_min: 1,
+            dimensions_count_max: 1,
+          },
+          {
+            chart_class: Chart::ParallelSet,
+            chart_roles: [:dimension],
+            dimensions_count_min: 3,
+          },
+        ].freeze
+      end
+
+      def descriptive_statistics(values)
+        frequencies = values.inject(Hash.new(0)) { |m,e| m[e] += 1; m }
+        total_count = values.length
+        ruby_formatters = {
+          :integer => Proc.new { |v| number_with_delimiter(v.round) },
+          :percent => Proc.new { |v| number_to_percentage(v, :precision => 3, :significant => true, :strip_insignificant_zeros => true, :delimiter => ',') },
+        }
+        r = frequencies.inject([]) { |m, (k,v)|
+          m << { :label => "#{ k.to_s }_count", :value => v, :ruby_formatter => ruby_formatters[:integer] }
+          m << { :label => "#{ k.to_s }_percent", :value => (v / total_count.to_f) * 100, :ruby_formatter => ruby_formatters[:percent] }
+          m
+        }.sort { |a,b| b[:value] <=> a[:value] }
+        r.insert(0, { :label => 'Total_count', :value => total_count, :ruby_formatter => ruby_formatters[:integer] })
+        r.insert(0, { :label => 'Total_percent', :value => 100, :ruby_formatter => ruby_formatters[:percent] })
+        r
+      end
+
+      # Returns an OpenStruct that describes a statistics table.
+      def descriptive_statistics_table(values)
+        desc_stats = descriptive_statistics(values)
+        labels = desc_stats.map { |e| e[:label].gsub(/_count|_percent/, '') }.uniq
+        table = OpenStruct.new(
+          :rows => []
+        )
+        table.rows << OpenStruct.new(
+          :css_class => 'rde-column_header',
+          :tag => :tr,
+          :cells => labels.map { |label|
+            OpenStruct.new(:value => label, :ruby_formatter => Proc.new { |e| e }, :tag => :th, :css_class => 'rde-cell-label')
+          }
+        )
+        table.rows << OpenStruct.new(
+          :css_class => 'rde-data_row',
+          :tag => :tr,
+          :cells => labels.map { |label|
+            stat = desc_stats.detect { |e| "#{ label }_count" == e[:label] }
+            OpenStruct.new(:value => stat[:value], :ruby_formatter => stat[:ruby_formatter], :tag => :td, :css_class => 'rde-cell-value')
+          }
+        )
+        table.rows << OpenStruct.new(
+          :css_class => 'rde-data_row',
+          :tag => :tr,
+          :cells => labels.map { |label|
+            stat = desc_stats.detect { |e| "#{ label }_percent" == e[:label] }
+            OpenStruct.new(:value => stat[:value], :ruby_formatter => stat[:ruby_formatter], :tag => :td, :css_class => 'rde-cell-value')
+          }
+        )
+        table
+      end
+
+      def axis_tick_format(values)
+        %(function(d) { return d })
+      end
+
+    end
+  end
+end

data/lib/rails-data-explorer/data_type/geo.rb

@@ -0,0 +1 @@
+# For displaying data on maps.

data/lib/rails-data-explorer/data_type/quantitative.rb

@@ -0,0 +1,109 @@
+class RailsDataExplorer
+  class DataType
+    class Quantitative < DataType
+
+      # This is an abstract class. Use sub_classes
+
+      def all_available_chart_types
+        [
+          {
+            chart_class: Chart::BoxPlot,
+            chart_roles: [:y],
+            dimensions_count_min: 1,
+            dimensions_count_max: 1
+          },
+          {
+            chart_class: Chart::HistogramQuantitative,
+            chart_roles: [:x],
+            dimensions_count_min: 1,
+            dimensions_count_max: 1
+          },
+          {
+            chart_class: Chart::BoxPlotGroup,
+            chart_roles: [:x],
+            dimensions_count_min: 2,
+            dimensions_count_max: 2,
+          },
+          {
+            chart_class: Chart::Scatterplot,
+            chart_roles: [:x, :y, :size],
+            dimensions_count_min: 2
+          },
+          {
+            chart_class: Chart::DescriptiveStatisticsTable,
+            chart_roles: [:any],
+            dimensions_count_min: 1,
+            dimensions_count_max: 1
+          },
+          {
+            chart_class: Chart::ParallelCoordinates,
+            chart_roles: [:dimension],
+            dimensions_count_min: 3,
+          },
+        ].freeze
+      end
+
+      def descriptive_statistics(values)
+        stats = ::DescriptiveStatistics::Stats.new(values)
+        ruby_formatters = {
+          :integer => Proc.new { |v| number_with_delimiter(v.round) },
+          :decimal => Proc.new { |v| number_with_precision(v, :precision => 3, :significant => true, :strip_insignificant_zeros => true, :delimiter => ',') },
+          :pass_through => Proc.new { |v| v },
+        }
+        [
+          { :label => 'Min', :value => stats.min, :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '1%ile', :value => stats.value_from_percentile(1), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '10%ile', :value => stats.value_from_percentile(10), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '25%ile', :value => stats.value_from_percentile(25), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => 'Median', :value => stats.median, :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '75%ile', :value => stats.value_from_percentile(75), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '90%ile', :value => stats.value_from_percentile(90), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '99%ile', :value => stats.value_from_percentile(99), :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => 'Max', :value => stats.max, :ruby_formatter => ruby_formatters[:decimal], :table_row => 1 },
+          { :label => '', :value => '', :ruby_formatter => ruby_formatters[:pass_through], :table_row => 1 },
+
+          { :label => 'Range', :value => stats.range, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Mean', :value => stats.mean, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Mode', :value => stats.mode, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Count', :value => values.length, :ruby_formatter => ruby_formatters[:integer], :table_row => 2 },
+          { :label => 'Sum', :value => values.inject(0) { |m,e| m += e }, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Variance', :value => stats.variance, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Std. dev.', :value => stats.standard_deviation, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Rel. std. dev.', :value => stats.relative_standard_deviation, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Skewness', :value => stats.skewness, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+          { :label => 'Kurtosis', :value => stats.kurtosis, :ruby_formatter => ruby_formatters[:decimal], :table_row => 2 },
+        ]
+      end
+
+      # Returns an OpenStruct that describes a statistics table.
+      def descriptive_statistics_table(values)
+        desc_stats = descriptive_statistics(values)
+        table = OpenStruct.new(
+          :rows => []
+        )
+        [1,2].each do |table_row|
+          table.rows << OpenStruct.new(
+            :css_class => 'rde-column_header',
+            :tag => :tr,
+            :cells => desc_stats.find_all { |e| table_row == e[:table_row] }.map { |stat|
+              OpenStruct.new(:value => stat[:label], :ruby_formatter => Proc.new { |e| e }, :tag => :th, :css_class => 'rde-cell-label')
+            }
+          )
+          table.rows << OpenStruct.new(
+            :css_class => 'rde-data_row',
+            :tag => :tr,
+            :cells => desc_stats.find_all { |e| table_row == e[:table_row] }.map { |stat|
+              OpenStruct.new(:value => stat[:value], :ruby_formatter => stat[:ruby_formatter], :tag => :td, :css_class => 'rde-cell-value')
+            }
+          )
+        end
+        table
+      end
+
+      def axis_tick_format(values)
+        raise "Implement me in sub_class"
+      end
+
+    end
+  end
+end

data/lib/rails-data-explorer/data_type/quantitative/decimal.rb

@@ -0,0 +1,13 @@
+class RailsDataExplorer
+  class DataType
+    class Quantitative
+      class Decimal < Quantitative
+
+        def axis_tick_format(values)
+          "d3.format('.02f')"
+        end
+
+      end
+    end
+  end
+end

data/lib/rails-data-explorer/data_type/quantitative/integer.rb

@@ -0,0 +1,13 @@
+class RailsDataExplorer
+  class DataType
+    class Quantitative
+      class Integer < Quantitative
+
+        def axis_tick_format(values)
+          "d3.format('r')"
+        end
+
+      end
+    end
+  end
+end

data/lib/rails-data-explorer/data_type/quantitative/temporal.rb

@@ -0,0 +1,62 @@
+class RailsDataExplorer
+  class DataType
+    class Quantitative
+      class Temporal < Quantitative
+
+        def all_available_chart_types
+          [
+            {
+              :chart_class => Chart::HistogramTemporal,
+              :chart_roles => [:x],
+              :dimensions_count_min => 1,
+              :dimensions_count_max => 1
+            },
+            {
+              chart_class: Chart::DescriptiveStatisticsTable,
+              chart_roles: [:any],
+              dimensions_count_min: 1,
+              dimensions_count_max: 1
+            },
+            {
+              chart_class: Chart::ParallelCoordinates,
+              chart_roles: [:dimension],
+              dimensions_count_min: 3,
+            },
+          ].freeze
+        end
+
+        def descriptive_statistics(values)
+          ruby_formatter = Proc.new { |v| v.nil? ? '' : v.strftime('%a, %b %e, %Y, %l:%M:%S %p %Z') }
+          [
+            { :label => 'Min', :value => values.min, :ruby_formatter => ruby_formatter },
+            { :label => 'Max', :value => values.max, :ruby_formatter => ruby_formatter },
+            { :label => 'Count', :value => values.length, :ruby_formatter => Proc.new { |e| number_with_delimiter(e) } },
+          ]
+        end
+
+        # Returns an OpenStruct that describes a statistics table.
+        def descriptive_statistics_table(values)
+          desc_stats = descriptive_statistics(values)
+          table = OpenStruct.new(
+            :rows => desc_stats.map { |stat|
+              OpenStruct.new(
+                :css_class => 'rde-row-values',
+                :tag => :tr,
+                :cells => [
+                  OpenStruct.new(:value => stat[:label], :tag => :th, :css_class => 'rde-row_header'),
+                  OpenStruct.new(:value => stat[:value], :ruby_formatter => stat[:ruby_formatter], :tag => :td, :css_class => 'rde-cell-value'),
+                ]
+              )
+            }
+          )
+          table
+        end
+
+        def axis_tick_format(values)
+          %(function(d) { return d3.time.format('%x')(new Date(d)) })
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'rails'
+
+class RailsDataExplorer
+  class Engine < ::Rails::Engine
+
+    # It's an engine so that we can add javascript and image assets
+    # to the asset pipeline.
+
+    # initializer "rails-data-explorer.active_record_extension" do |app|
+    #   require 'rails-data-explorer/active_record_extension'
+    #   class ::ActiveRecord::Base
+    #     extend RailsDataExplorer::ActiveRecordExtension::ClassMethods
+    #   end
+    # end
+
+    # initializer "rails-data-explorer.action_view_extension" do |app|
+    #   require 'rails-data-explorer/action_view_extension'
+    #   class ::ActionView::Base
+    #     include RailsDataExplorer::ActionViewExtension
+    #   end
+    # end
+
+  end
+end

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

@@ -0,0 +1,89 @@
+class RailsDataExplorer
+  class Exploration
+
+    attr_accessor :output_buffer # required for content_tag
+    include ActionView::Helpers::TagHelper
+
+    attr_accessor :charts, :data_set, :title
+
+    # Initializes a new visualization.
+    # @param[String] _title will be printed at top of visualization
+    # @param[Array] data_set_or_array can be a number of things:
+    #  * Array<Scalar> - for single data series, uni-variate options are applied.
+    #  * Array<Hash> - for multiple data series, bi/multi-variate options are applied.
+    #  * DataSet - For finer grained control.
+    # @param[Array<Chart, String, Symbol>, optional] chart_specs
+    #  The list of charts to include. Defaults to all applicable charts for the
+    #  given data_set_or_array.
+    #  Charts can be provided as Array of Strings, Symbols, or Chart classes
+    #  (can be mixed).
+    def initialize(_title, data_set_or_array, chart_specs=nil)
+      @title = _title
+      @data_set = initialize_data_set(data_set_or_array)
+      @charts = initialize_charts(chart_specs)
+    end
+
+    def render
+      content_tag(:div, :class => 'rde-exploration panel panel-default', :id => dom_id) do
+        content_tag(:div, :class => 'panel-heading') do
+          content_tag(:h2, @title, :class => 'rde-exploration-title panel-title')
+        end +
+        content_tag(:div, :class => 'panel-body') do
+          @charts.map { |e| e.render }.join.html_safe
+        end
+      end.html_safe
+    end
+
+    def dom_id
+      "rde-exploration-#{ object_id }"
+    end
+
+    def inspect(indent=1, recursive=1000)
+      r = %(#<#{ self.class.to_s }\n)
+      r << [
+        "@title=#{ @title.inspect }",
+      ].map { |e| "#{ '  ' * indent }#{ e }\n"}.join
+      if recursive > 0
+        r << %(#{ '  ' * indent }@data_set=)
+        r << data_set.inspect(indent + 1, recursive - 1)
+      end
+      r << %(#{ '  ' * (indent-1) }>\n)
+    end
+
+  private
+
+    def initialize_charts(chart_specs)
+      if chart_specs.present?
+        chart_specs.map { |chart_spec|
+          case chart_spec
+          when Chart
+          when String, Symbol
+          else
+          end
+        }
+      else
+        @data_set.available_chart_types.map { |e|
+          e.send(:new, @data_set)
+        }
+      end
+    end
+
+    def initialize_data_set(data_set_or_array)
+      case data_set_or_array
+      when Array
+        DataSet.new(data_set_or_array, @title)
+      when DataSet
+        # use as is
+        _data_set
+      else
+        raise(
+          ArgumentError.new(
+            "data_set_or_array must be an Array or a DataSet, " + \
+            "is #{ data_set_or_array.class.to_s }"
+          )
+        )
+      end
+    end
+
+  end
+end