rails-data-explorer 0.0.1 → 0.1.0

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

@@ -29,7 +29,11 @@ class RailsDataExplorer
           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
+          if @charts.any?
+            @charts.map { |e| e.render }.join.html_safe
+          else
+            "No charts are available for this combination of data series."
+          end
         end
       end.html_safe
     end

data/lib/rails-data-explorer/utils/data_binner.rb

@@ -6,3 +6,34 @@
 # * 21 - 30
 # * 31 - 40
 # * > 40
+class RailsDataExplorer
+  module Utils
+    class DataBinner
+
+      def initialize(*args)
+        @max = -Float::INFINITY
+        @bin_specs = [*args].compact.uniq.sort.map { |e|
+          case e
+          when Numeric
+            @max = [@max, e].max
+            { :label => "#{ e.to_s } or less", :lte => e }
+          else
+            raise "Handle this bin_spec: #{ e.inspect }"
+          end
+        }
+        @bin_specs << { :label => "> #{ @max }", :gt => @max }
+      end
+
+      def bin(value)
+        unless value.is_a?(Numeric)
+          raise(ArgumentError.new("Wrong type of value, numeric expected, got: #{ value.inspect }"))
+        end
+        bin = @bin_specs.detect { |bs|
+          (bs[:lte] && value <= bs[:lte]) || (bs[:gt] && value > bs[:gt])
+        }
+        bin[:label]
+      end
+
+    end
+  end
+end

data/lib/rails-data-explorer/utils/data_quantizer.rb

@@ -1,2 +1,68 @@
 # Map a large set of quantitative/temporal/geo input values to a (countable)
 # smaller set – such as rounding values to some unit of precision.
+class RailsDataExplorer
+  module Utils
+    class DataQuantizer
+
+      attr_accessor :number_of_bins, :delta
+
+      def initialize(data_series, options = {})
+        @options = {
+          :nice => true,
+          :type => 'midtread', # 'midtread' or 'midrise'
+          :number_of_bins => 100, # assuming 800px wide chart, 8px per bin
+          :delta => nil,
+        }.merge(options)
+        @data_series = data_series
+        @number_of_bins = @options[:number_of_bins]
+        init_attrs
+      end
+
+      def init_attrs
+        # Compute boundaries
+        if @options[:nice]
+          range = @data_series.max_val - @data_series.min_val
+          rounding_factor = 10.0 ** Math.log10(range).floor
+          @min_val = (@data_series.min_val / rounding_factor).floor * rounding_factor
+          @max_val = (@data_series.max_val / rounding_factor).ceil * rounding_factor
+        else
+          @min_val = @data_series.min_val
+          @max_val = @data_series.max_val
+        end
+        # Compute delta
+        @delta = if @options[:delta]
+          @options[:delta]
+        else
+          (@max_val - @min_val) / @number_of_bins.to_f
+        end
+      end
+
+      def values
+        @values ||= (
+          case @options[:type]
+          when 'midrise'
+            @data_series.values.map { |e|
+              index_of_quantized_value = ((e - @min_val) / @delta).round
+              (
+                (index_of_quantized_value * @delta) +
+                (@delta / 2.0) +
+                @min_val
+              )
+            }
+          when 'midtread'
+            @data_series.values.map { |e|
+              index_of_quantized_value = ((e - @min_val) / @delta).round
+              (
+                (index_of_quantized_value * @delta) +
+                @min_val
+              )
+            }
+          else
+            raise "Handle this type: #{ @options[:type].inspect }"
+          end
+        )
+      end
+
+    end
+  end
+end

data/lib/rails_data_explorer.rb

@@ -0,0 +1,133 @@
+class RailsDataExplorer
+
+  attr_accessor :output_buffer # required for content_tag
+  include ActionView::Helpers::TagHelper
+
+  attr_reader :explorations
+
+  def initialize(data_collection, data_series_specs)
+    @explorations = []
+    univariate = []
+    bivariate = {}
+    multivariate = {}
+
+    data_series_specs.each do |data_series_spec|
+      ds_spec = {
+        :univariate => true,
+        :bivariate => true,
+      }.merge(data_series_spec)
+      univariate << ds_spec.dup  if ds_spec[:univariate]
+
+      if ds_spec[:bivariate]
+        [*ds_spec[:bivariate]].each { |group_key|
+          group_key = group_key.to_s
+          bivariate[group_key] ||= []
+          bivariate[group_key] << ds_spec.dup
+        }
+      end
+
+      if ds_spec[:multivariate]
+        [*ds_spec[:multivariate]].each { |group_key|
+          group_key = group_key.to_s
+          multivariate[group_key] ||= []
+          multivariate[group_key] << ds_spec.dup
+        }
+      end
+    end
+
+    univariate.uniq.compact.each { |data_series_spec|
+      @explorations << Exploration.new(
+        data_series_spec[:name],
+        data_collection.map(&data_series_spec[:data_method]),
+      )
+    }
+
+    bivariate.each { |group_key, bv_data_series_specs|
+      next  unless group_key # skip if key is falsey
+      bv_data_series_specs.uniq.compact.combination(2) { |ds_specs_pair|
+        @explorations << build_exploration_from_data_series_specs(
+          data_collection,
+          ds_specs_pair
+        )
+      }
+    }
+
+    multivariate.each { |group_key, mv_data_series_specs|
+      next  unless group_key # skip key `false` or `nil`
+      ds_specs = mv_data_series_specs.uniq.compact
+      @explorations << build_exploration_from_data_series_specs(
+        data_collection,
+        ds_specs
+      )
+    }
+  end
+
+  def render
+    expls = separate_explorations_with_and_without_charts
+    r = render_toc(expls[:with])
+    r << render_charts(expls[:with])
+    r << render_explorations_without_charts(expls[:without])
+    r
+  end
+
+private
+
+  def build_exploration_from_data_series_specs(data_collection, ds_specs)
+    Exploration.new(
+      ds_specs.map { |e| e[:name] }.sort.join(' vs. '),
+      ds_specs.map { |ds_spec|
+        {
+          :name => ds_spec[:name],
+          :values => data_collection.map(&ds_spec[:data_method])
+        }
+      }
+    )
+  end
+
+  def render_toc(expls)
+    content_tag(:div, :class => 'rde panel panel-primary') do
+      content_tag(:div, :class => 'panel-heading') do
+        content_tag(:h2, "Table of contents", :class => 'rde-exploration-title panel-title')
+      end +
+      content_tag(:div, :class => 'panel-body') do
+        content_tag(:ul, :class => 'rde-table_of_contents') do
+          expls.map { |expl|
+            content_tag(
+              :li,
+              %(<a href="##{ expl.dom_id }">#{ expl.title }</a>).html_safe
+            )
+          }.join.html_safe
+        end
+      end
+    end
+  end
+
+  def render_charts(expls)
+    expls.map { |e| e.render }.join.html_safe
+  end
+
+  def render_explorations_without_charts(expls)
+    return ''  if expls.empty?
+    content_tag(:div, :class => 'rde panel panel-default') do
+      content_tag(:div, :class => 'panel-heading') do
+        content_tag(:h2, "Explorations without charts", :class => 'rde-exploration-title panel-title')
+      end +
+      content_tag(:div, :class => 'panel-body') do
+        content_tag(:p, "There are no charts available for the following explorations:") +
+        content_tag(:ul) do
+          expls.map { |expl|
+            content_tag(:li, expl.title).html_safe
+          }.join.html_safe
+        end
+      end
+    end
+  end
+
+  def separate_explorations_with_and_without_charts
+    explorations.inject({ :with => [], :without => [] }) { |m, e|
+      m[e.charts.any? ? :with : :without] << e
+      m
+    }
+  end
+
+end

data/rails-data-explorer.gemspec

@@ -3,7 +3,7 @@ $:.push File.expand_path('../lib', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.name = 'rails-data-explorer'
-  gem.version = '0.0.1'
+  gem.version = '0.1.0'
   gem.platform = Gem::Platform::RUBY
 
   gem.authors = ['Jo Hund']
@@ -16,15 +16,15 @@ Gem::Specification.new do |gem|
   gem.files = `git ls-files`.split("\n")
   gem.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
 
-  # really it's only ActiveSupport and ActionView
-  gem.add_dependency 'actionview', '>= 3.0.0'
   gem.add_dependency 'color'
   gem.add_dependency 'descriptive-statistics'
   gem.add_dependency 'distribution'
   gem.add_dependency 'interpolate'
 
+  gem.add_development_dependency 'actionview', '>= 3.0.0'
   gem.add_development_dependency 'bundler', ['>= 1.0.0']
-  gem.add_development_dependency 'rake', ['>= 0']
   gem.add_development_dependency 'minitest'
   gem.add_development_dependency 'minitest-spec-expect'
+  gem.add_development_dependency 'rake', ['>= 0']
+  gem.add_development_dependency 'yui-compressor'
 end

data/spec/helper.rb

@@ -0,0 +1,7 @@
+# dependencies
+require 'rubygems'
+require 'minitest'
+require 'minitest/autorun'
+
+# Gem under test
+require 'rails-data-explorer'

data/spec/helper_no_rails.rb

@@ -0,0 +1,10 @@
+# dependencies
+require 'rubygems'
+require 'minitest'
+require 'minitest/autorun'
+
+# Gem under test
+require 'rails-data-explorer-no-rails'
+
+# To silence deprecation notice
+I18n.enforce_available_locales = false

data/spec/rails-data-explorer/data_series_spec.rb

@@ -0,0 +1,45 @@
+require_relative '../helper_no_rails'
+
+class RailsDataExplorer
+  describe DataSeries do
+
+    describe "#initialize" do
+
+      [
+        [['a'], DataType::Categorical],
+        [[nil, 'a'], DataType::Categorical],
+        [[1.0], DataType::Quantitative::Decimal],
+        [[1], DataType::Quantitative::Integer],
+        [[Time.now], DataType::Quantitative::Temporal],
+      ].each_with_index { |(values, xpect), idx|
+        it "detects the datatype #{ idx } correctly" do
+          DataSeries.new("name", values).data_type.must_be_instance_of xpect
+        end
+      }
+
+    end
+
+    describe "value accessors" do
+
+      let(:ds) { DataSeries.new("name", ['b', 'a', 'a', 'c']) }
+
+      it "computes uniq_vals" do
+        ds.uniq_vals.must_equal ['b', 'a', 'c']
+      end
+
+      it "computes uniq_vals_count" do
+        ds.uniq_vals_count.must_equal 3
+      end
+
+      it "computes min_val" do
+        ds.min_val.must_equal 'a'
+      end
+
+      it "computes max_val" do
+        ds.max_val.must_equal 'c'
+      end
+
+    end
+
+  end
+end

data/spec/rails-data-explorer/data_type/categorical_spec.rb

@@ -0,0 +1,34 @@
+require_relative '../../helper_no_rails'
+
+class RailsDataExplorer
+  class DataType
+    describe Categorical do
+
+      let(:dt) { Categorical.new }
+      let(:values) { ['a', 'a', 'b', 'c'] }
+
+      describe "#descriptive_statistics" do
+
+        let(:desc_stats) {
+          dt.descriptive_statistics(values)
+        }
+
+        it "computes count for each uniq val" do
+          desc_stats.detect{ |e| 'a_count' == e[:label] }[:value].must_equal 2
+        end
+
+        it "computes percent for each uniq val" do
+          desc_stats.detect{ |e| 'a_percent' == e[:label] }[:value].must_equal 50.0
+        end
+
+        it "computes total count" do
+          desc_stats.detect{ |e| 'Total_count' == e[:label] }[:value].must_equal 4
+        end
+      end
+
+      describe "#available_chart_types" do
+      end
+
+    end
+  end
+end

data/spec/rails-data-explorer/exploration_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../helper_no_rails'
+
+class RailsDataExplorer
+  describe Exploration do
+
+    describe "integration test" do
+
+      def check_render_expectations(rendered_string, options)
+        r = true
+
+        if options[:has_charts]
+          options[:has_charts].each { |chart_name|
+            # TODO: use Nokogiri to test that it is a div class
+            rendered_string.must_match(
+              Regexp.new(Regexp.escape("rde-#{ chart_name }"))
+            )
+          }
+        end
+
+        r
+      end
+
+      [
+        [
+          ['Univariate Integer data', [nil, 1, 2, 3]],
+          { :has_charts => ['histogram-quantitative', 'descriptive-statistics-table'] }
+        ],
+        [
+          ['Univariate Decimal data', [nil, 1.0, 2.0, 3.0]],
+          { :has_charts => ['histogram-quantitative', 'descriptive-statistics-table'] }
+        ],
+        [
+          ['Univariate Temporal data', [nil, Time.now]],
+          { :has_charts => ['histogram-temporal', 'descriptive-statistics-table'] }
+        ],
+        [
+          ['Univariate Categorical data', [nil, 'a', 'b', 'c']],
+          { :has_charts => ['histogram-categorical', 'pie-chart', 'descriptive-statistics-table'] }
+        ],
+      ].each { |(args, xpect_options)|
+        title, data_set_or_array, chart_specs = args
+
+        it "renders #{ title } correctly" do
+          check_render_expectations(
+            Exploration.new(*args).render,
+            xpect_options
+          )
+        end
+
+      }
+
+    end
+
+  end
+end

data/spec/rails-data-explorer/utils/data_binner_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../../helper_no_rails'
+
+class RailsDataExplorer
+  module Utils
+    describe DataBinner do
+
+      describe '#bin' do
+
+        [
+          [
+            '1',
+            [1,2,3],
+            [0,1,2,3,4],
+            ["1 or less", "1 or less", "2 or less", "3 or less", "> 3"]
+          ],
+        ].each do |(name, bin_specs, vals, xpect)|
+
+          it "bins #{ name }" do
+            db = DataBinner.new(*bin_specs)
+            vals.map{ |e| db.bin(e) }.must_equal xpect
+          end
+
+        end
+
+      end
+
+    end
+  end
+end