rails-data-explorer 0.1.0 → 0.2.0

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

@@ -14,6 +14,9 @@ class RailsDataExplorer
           m[key] += 1
           m
         }
+        histogram_values_ds = DataSeries.new('_', h.values)
+        y_scale_type = histogram_values_ds.axis_scale(:vega)
+        bar_y2_val = 'log' == y_scale_type ? histogram_values_ds.min_val / 10.0 : 0
         width = 800
         {
           values: h.map { |k,v| { x: k, y: v } },
@@ -25,6 +28,9 @@ class RailsDataExplorer
           bar_width: 2,
           y_axis_label: 'Frequency',
           y_axis_tick_format: "d3.format('r')",
+          y_scale_type: y_scale_type,
+          y_scale_domain: [bar_y2_val, histogram_values_ds.max_val],
+          bar_y2_val: bar_y2_val,
         }
       end
 

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

@@ -81,10 +81,10 @@ class RailsDataExplorer
           m
         }
         {
-          :dimensions => dimension_names,
-          :values => dimension_values,
-          :types => dimension_types,
-          :alpha => 1 / ([Math.log([number_of_values, 2].max), 10].min) # from 1.0 to 0.1
+          dimensions: dimension_names,
+          values: dimension_values,
+          types: dimension_types,
+          alpha: 1 / ([Math.log([number_of_values, 2].max), 10].min) # from 1.0 to 0.1
         }
       end
 

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

@@ -11,7 +11,7 @@ class RailsDataExplorer
 
       def compute_chart_attrs
         dimension_data_series = @data_set.data_series.find_all { |ds|
-          (ds.chart_roles[Chart::ParallelCoordinates] & [:dimension, :any]).any?
+          (ds.chart_roles[Chart::ParallelSet] & [:dimension, :any]).any?
         }
         return false  if dimension_data_series.empty?
 
@@ -28,8 +28,8 @@ class RailsDataExplorer
           }
         end
         {
-          :dimensions => dimension_names,
-          :values => dimension_values
+          dimensions: dimension_names,
+          values: dimension_values
         }
       end
 

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

@@ -9,10 +9,10 @@ class RailsDataExplorer
 
       def compute_chart_attrs
         x_candidates = @data_set.data_series.find_all { |ds|
-          (ds.chart_roles[Chart::ContingencyTable] & [:x, :any]).any?
+          (ds.chart_roles[Chart::StackedBarChartCategoricalPercent] & [: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?
+          (ds.chart_roles[Chart::StackedBarChartCategoricalPercent] & [:y, :any]).any?
         }
 
         x_ds = x_candidates.first
@@ -20,7 +20,7 @@ class RailsDataExplorer
         return false  if x_ds.nil? || y_ds.nil?
 
         # initialize data_matrix
-        data_matrix = { :_sum => { :_sum => 0 } }
+        data_matrix = { _sum: { _sum: 0 } }
         x_ds.uniq_vals.each { |x_val|
           data_matrix[x_val] = {}
           data_matrix[x_val][:_sum] = 0

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

@@ -0,0 +1,5 @@
+class RailsDataExplorer
+
+  GREATER_ZERO = 1.0 / 1_000_000 # The smallest value to use if we have to avoid zero (div by zero)
+
+end

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

@@ -5,20 +5,20 @@ class RailsDataExplorer
     # 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
+    delegate :available_chart_types, to: :data_type, prefix: false
+    delegate :available_chart_roles, to: :data_type, prefix: false
 
     # Any data series with a dynamic range greater than this is considered
     # having a large dynamic range
     # We consider dynamic range the ratio between the largest and the smallest value.
-    def self.large_dynamic_range_cutoff
-      1000.0
+    def self.large_dynamic_range_threshold
+      10000.0
     end
 
     # Any data series with more than this uniq vals is considered having many
     # uniq values.
-    def self.many_uniq_vals_cutoff
-      20
+    def self.many_uniq_vals_threshold
+      30
     end
 
     # options: :chart_roles, :data_type (all optional)
@@ -40,6 +40,10 @@ class RailsDataExplorer
       @data_type.descriptive_statistics_table(values)
     end
 
+    def number_of_values
+      values.length
+    end
+
     def values_summary
       if values.length < 3 || values.inspect.length < 80
         values.inspect
@@ -66,37 +70,39 @@ class RailsDataExplorer
       data_type.axis_tick_format(values)
     end
 
-    def axis_scale
-      data_type.axis_scale(self)
+    # @param[Symbol] d3_or_vega :d3 or :vega
+    def axis_scale(d3_or_vega)
+      data_type.axis_scale(self, d3_or_vega)
     end
 
     def uniq_vals
-      @uniq_vals = values.uniq
+      @uniq_vals ||= values.uniq
     end
 
     def uniq_vals_count
-      @uniq_vals_count = uniq_vals.length
+      @uniq_vals_count ||= uniq_vals.length
     end
 
     def min_val
-      @min_val = values.compact.min
+      @min_val ||= values.compact.min
     end
 
     def max_val
-      @max_val = values.compact.max
+      @max_val ||= values.compact.max
     end
 
     # Used to decide whether we can render certain chart types
     def has_many_uniq_vals?
-      uniq_vals_count > self.class.many_uniq_vals_cutoff
+      uniq_vals_count > self.class.many_uniq_vals_threshold
     end
 
     def dynamic_range
+      # TODO: avoid division by zero
       max_val / [min_val, max_val].min.to_f
     end
 
     def has_large_dynamic_range?
-      dynamic_range > self.class.large_dynamic_range_cutoff
+      dynamic_range > self.class.large_dynamic_range_threshold
     end
 
     def label_sorter(label_val_key, value_sorter)

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

@@ -58,6 +58,10 @@ class RailsDataExplorer
       # TODO: all elements in a series are of same type
     end
 
+    def number_of_values
+      @data_series.first.number_of_values
+    end
+
     def dimensions_count
       @data_series.length
     end

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

@@ -2,20 +2,22 @@ class RailsDataExplorer
   class DataType
     class Categorical < DataType
 
+      # TODO: when there are too many categories, only separate the N most
+      # significant ones and group all other values under "Other"
       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::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],
@@ -38,6 +40,12 @@ class RailsDataExplorer
             dimensions_count_min: 2,
             dimensions_count_max: 2,
           },
+          {
+            chart_class: Chart::StackedHistogramTemporal,
+            chart_roles: [:y],
+            dimensions_count_min: 2,
+            dimensions_count_max: 2,
+          },
           {
             chart_class: Chart::ContingencyTable,
             chart_roles: [:any],
@@ -60,25 +68,31 @@ class RailsDataExplorer
 
       def descriptive_statistics(values)
         frequencies = values.inject(Hash.new(0)) { |m,e| m[e] += 1; m }
+        labels_ds = DataSeries.new('_', values.uniq)
         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 => ',') },
+          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 << { 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] })
+        }.sort(
+          &labels_ds.label_sorter(
+            :label,
+            lambda { |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.
+      # Returns an object that describes a statistics table.
       def descriptive_statistics_table(values)
         desc_stats = descriptive_statistics(values)
-        if desc_stats.length < DataSeries.many_uniq_vals_cutoff
+        if desc_stats.length < DataSeries.many_uniq_vals_threshold
           descriptive_statistics_table_horizontal(desc_stats)
         else
           descriptive_statistics_table_vertical(desc_stats)
@@ -87,68 +101,64 @@ class RailsDataExplorer
 
       def descriptive_statistics_table_horizontal(desc_stats)
         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 = Utils::RdeTable.new([])
+        table.rows << Utils::RdeTableRow.new(
+          :tr,
+          labels.map { |label|
+            Utils::RdeTableCell.new(:th, label, ruby_formatter: Proc.new { |e| e }, css_class: 'rde-cell-label')
+          },
+          css_class: 'rde-column_header'
         )
-        table.rows << OpenStruct.new(
-          :css_class => 'rde-data_row',
-          :tag => :tr,
-          :cells => labels.map { |label|
+        table.rows << Utils::RdeTableRow.new(
+          :tr,
+          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')
-          }
+            Utils::RdeTableCell.new(:td, stat[:value], ruby_formatter: stat[:ruby_formatter], css_class: 'rde-cell-value')
+          },
+          css_class: 'rde-data_row'
         )
-        table.rows << OpenStruct.new(
-          :css_class => 'rde-data_row',
-          :tag => :tr,
-          :cells => labels.map { |label|
+        table.rows << Utils::RdeTableRow.new(
+          :tr,
+          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')
-          }
+            Utils::RdeTableCell.new(:td, stat[:value], ruby_formatter: stat[:ruby_formatter], css_class: 'rde-cell-value')
+          },
+          css_class: 'rde-data_row'
         )
         table
       end
 
       def descriptive_statistics_table_vertical(desc_stats)
         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 => %w[Value Count Percent].map { |label|
-            OpenStruct.new(:value => label, :tag => :th, :css_class => 'rde-cell-label')
-          }
+        table = Utils::RdeTable.new([])
+        table.rows << Utils::RdeTableRow.new(
+          :tr,
+          %w[Value Count Percent].map { |label|
+            Utils::RdeTableCell.new(:th, label, css_class: 'rde-cell-label')
+          },
+          css_class: 'rde-column_header',
         )
         labels.each { |label|
           count_stat = desc_stats.detect { |e| "#{ label }_count" == e[:label] }
           percent_stat = desc_stats.detect { |e| "#{ label }_percent" == e[:label] }
-          table.rows << OpenStruct.new(
-            :css_class => 'rde-data_row',
-            :tag => :tr,
-            :cells => [
-              OpenStruct.new(:value => label, :tag => :td, :css_class => 'rde-cell-value'),
-              OpenStruct.new(
-                :value => count_stat[:value],
-                :ruby_formatter => count_stat[:ruby_formatter],
-                :tag => :td,
-                :css_class => 'rde-cell-value'
+          table.rows << Utils::RdeTableRow.new(
+            :tr,
+            [
+              Utils::RdeTableCell.new(:td, label, css_class: 'rde-cell-value'),
+              Utils::RdeTableCell.new(
+                :td,
+                count_stat[:value],
+                ruby_formatter: count_stat[:ruby_formatter],
+                css_class: 'rde-cell-value'
               ),
-              OpenStruct.new(
-                :value => percent_stat[:value],
-                :ruby_formatter => percent_stat[:ruby_formatter],
-                :tag => :td,
-                :css_class => 'rde-cell-value'
+              Utils::RdeTableCell.new(
+                :td,
+                percent_stat[:value],
+                ruby_formatter: percent_stat[:ruby_formatter],
+                css_class: 'rde-cell-value'
               ),
-            ]
+            ],
+            css_class: 'rde-data_row',
           )
         }
         table
@@ -163,18 +173,20 @@ class RailsDataExplorer
       # @param[Proc] value_sorter the sorting proc to use if not sorted numerically
       # @return[Proc] a Proc that will be used by #sort
       def label_sorter(label_val_key, data_series, value_sorter)
-        if data_series.uniq_vals.any? { |e| e.to_s =~ /^\d+/ }
+        if data_series.uniq_vals.any? { |e| e.to_s =~ /^[\+\-]?\d+/ }
           # Sort numerical categories by key ASC
           lambda { |a,b|
-            number_extractor = lambda { |val|
+            number_and_full_string_extractor = lambda { |val|
               str = label_val_key ? val[label_val_key] : val
-              number = str.gsub(/^[^\d]*/, '').to_f
+              number = str.gsub(/^[^\d\+\-]*/, '') # remove non-digit leading chars
+                          .gsub(',', '') # remove delimiter commas, they throw off to_f parsing
+                          .to_f
               number += 1  if str =~ /^>/ # increase highest threshold by one for proper sorting
-              number
+              [number, str]
             }
-            a_number = number_extractor.call(a)
-            b_number = number_extractor.call(b)
-            a_number <=> b_number
+            a_number_and_full_string = number_and_full_string_extractor.call(a)
+            b_number_and_full_string = number_and_full_string_extractor.call(b)
+            a_number_and_full_string <=> b_number_and_full_string
           }
         else
           # Use provided value sorter

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

@@ -47,10 +47,10 @@ class RailsDataExplorer
         non_nil_values = values.find_all { |e| !(e.nil? || Float::NAN == e) }
         stats = ::DescriptiveStatistics::Stats.new(non_nil_values)
         ruby_formatters = {
-          :integer => Proc.new { |v|
+          integer: Proc.new { |v|
             v.nil? ? 'Null' : number_with_delimiter(v.round)
           },
-          :decimal => Proc.new { |v|
+          decimal: Proc.new { |v|
             case
             when v.nil?
               'Null'
@@ -59,62 +59,60 @@ class RailsDataExplorer
             else
               number_with_precision(
                 v,
-                :precision => 3,
-                :significant => true,
-                :strip_insignificant_zeros => true,
-                :delimiter => ','
+                precision: 3,
+                significant: true,
+                strip_insignificant_zeros: true,
+                delimiter: ','
               )
             end
           },
-          :pass_through => Proc.new { |v| (v.nil? || Float::NAN == v) ? 'NaN' : v },
+          pass_through: Proc.new { |v| (v.nil? || Float::NAN == v) ? 'NaN' : 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 => '5%ile', :value => stats.value_from_percentile(5), :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 => '95%ile', :value => stats.value_from_percentile(95), :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: '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: '5%ile', value: stats.value_from_percentile(5), 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: '95%ile', value: stats.value_from_percentile(95), 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 => '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 => non_nil_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 },
-          { :label => '', :value => '', :ruby_formatter => ruby_formatters[:pass_through], :table_row => 2 },
+          { 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: non_nil_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 },
+          { label: '', value: '', ruby_formatter: ruby_formatters[:pass_through], table_row: 2 },
         ]
       end
 
-      # Returns an OpenStruct that describes a statistics table.
+      # Returns an object that describes a statistics table.
       def descriptive_statistics_table(values)
         desc_stats = descriptive_statistics(values)
-        table = OpenStruct.new(
-          :rows => []
-        )
+        table = Utils::RdeTable.new([])
         [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 << Utils::RdeTableRow.new(
+            :tr,
+            desc_stats.find_all { |e| table_row == e[:table_row] }.map { |stat|
+              Utils::RdeTableCell.new(:th, stat[:label], ruby_formatter: Proc.new { |e| e }, css_class: 'rde-cell-label')
+            },
+            css_class: 'rde-column_header'
           )
-          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')
-            }
+          table.rows << Utils::RdeTableRow.new(
+            :tr,
+            desc_stats.find_all { |e| table_row == e[:table_row] }.map { |stat|
+              Utils::RdeTableCell.new(:td, stat[:value], ruby_formatter: stat[:ruby_formatter], css_class: 'rde-cell-value')
+            },
+            css_class: 'rde-data_row'
           )
         end
         table
@@ -124,12 +122,12 @@ class RailsDataExplorer
         raise "Implement me in sub_class"
       end
 
-      def axis_scale(data_series)
+      def axis_scale(data_series, d3_or_vega)
         # Log scales can't handle 0 values
         if data_series.min_val > 0.0 && data_series.has_large_dynamic_range?
-          'd3.scale.log'
+          { d3: 'd3.scale.log', vega: 'log' }[d3_or_vega]
         else
-          'd3.scale.linear'
+          { d3: 'd3.scale.linear', vega: 'linear' }[d3_or_vega]
         end
       end