rails-data-explorer 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 97a1736026323867194e064be61c520d93faeae5
-  data.tar.gz: 73a2d84730255fad42699c4a1b8b6ded248296b0
+  metadata.gz: 5b417c02b65c9c3f0fed2ddb85c5f6e992671aea
+  data.tar.gz: b0ff6ff26221174cf12ba739f5a6029ac636a0d1
 SHA512:
-  metadata.gz: db1654f07bff7cd93caf4498e75ea4360f8291da035e77513694ff5615e3a395fbd08d223f3a29f97898c88a0848ceb64fb2909ff2ddd7cc664ff8fb5ec36a07
-  data.tar.gz: 60713884e311d17d48e8c221f62fc1d47649407f1eef47e1f2356c163cf71268df168092126d36e5e28d2a1ce89262e00940ea61c77a5fe463222eda9be18acc
+  metadata.gz: 7badacd27cd2ed6059094d5aba6027918e342437c79ae938504b451c6572632c42d0abf1817c0ea7dc0e0c3083f037dd11acd455ab6e23784349908faf5a0c00
+  data.tar.gz: 597a4a2857756a8226582d69b3a2154ea1708e2c19a396a2cc94f2947d63a8126a8517b7242923d9b328384730bde98b3172a10a472ef8bc35d1d52d08daae20

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+there seems a huge inefficiency in RailsDataExplorer#build_exploration_from_data_series_specs
+where we iterate over the entire data collection for every exploration.
+
+
+### 0.2.3
+
+* Don't show all explorations by default. Takes too long when having 100
+  explorations to render. Instead show univariate explorations by default
+  and bivariate explorations on demand.
+
 ### 0.2.2
 
 * Fixed file inclusion bug that prevented loading of Gem

data/lib/rails-data-explorer.rb

@@ -5,6 +5,8 @@ require 'descriptive-statistics'
 require 'distribution'
 require 'interpolate'
 
+require 'rails-data-explorer/action_view_extension'
+
 require 'rails-data-explorer/engine'
 
 require 'rails_data_explorer'

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

@@ -1,11 +1,193 @@
+# -*- coding: utf-8 -*-
 #
 # Adds view helpers to ActionView
 #
 class RailsDataExplorer
   module ActionViewExtension
 
-    def render_explorations(explorations)
-      explorations.map { |e| e.render }
+    # Renders the entire RailsDataExplorer view
+    # @param rails_data_explorer [RailsDataExplorer]
+    def rails_data_explorer(rde)
+      content_tag(:div, class: 'rails-data-explorer') do
+        [
+          rde_toc(rde.data_series_names, rde.explorations_with_charts_available),
+          rde_explorations_with_charts(rde.explorations_with_charts_to_render),
+        ].join.html_safe
+      end
+    end
+
+    # Returns a url that can be used to reset the Filterrific params
+    def reset_filterrific_url(opts = {})
+      url_for(
+        { filterrific: { reset_filterrific: true } }.merge(opts)
+      )
+    end
+
+  protected
+
+    # @param ds_names [Array<String>] the names of the data_series
+    # @param explorations [Array<Exploration>]
+    def rde_toc(ds_names, explorations)
+      reversed_ds_names = ds_names.reverse
+      num_cols = 2 + ds_names.length
+      content_tag(:div, class: 'rde panel panel-primary') do
+        content_tag(:div, class: 'panel-heading') do
+          %(<a name="rails_data_explorer-toc"></a>).html_safe +
+          content_tag(:h2, "List of data explorations", class: 'rde-exploration-title panel-title')
+        end +
+        content_tag(:div, class: 'panel-body') do
+          content_tag(:table, class: 'table rde_toc-matrix') do
+            # render header row for analysis types
+            content_tag(:tr) do
+              content_tag(:th, 'Univariate', colspan: '2') +
+              content_tag(:th, 'Bivariate', colspan: ds_names.length)
+            end +
+            # render uni-/bi-variate analysis column headers (with reversed data_series names)
+            content_tag(:tr) do
+              content_tag(
+                :td,
+                link_to(
+                  'All Univariates ⬇',
+                  url_for(
+                    rde: {
+                      univariate: ds_names.each_with_index.inject({}) { |m, (e, idx)|
+                        m[idx] = [e]
+                        m
+                      }
+                    },
+                    anchor: 'rails_data_explorer-toc',
+                  ),
+                  class: 'btn btn-default btn-xs'
+                ),
+                colspan: 2
+              ) +
+              reversed_ds_names.map { |ds_name|
+                content_tag(:th, ds_name, class: 'rde_toc-col_header')
+              }.join.html_safe
+            end +
+            # iterate over data_series
+            ds_names.map { |ds_name|
+              content_tag(:tr) do
+                uv_expl = explorations.detect { |e|
+                  e.dom_id == RailsDataExplorer::Exploration.compute_dom_id(
+                    [ds_name]
+                  )
+                }
+                encountered_bv_with_self = false
+                # cell with name
+                content_tag(
+                  :th,
+                  ds_name.truncate(12),
+                  class: 'rde_toc-row_header',
+                  title: ds_name
+                ) +
+                # cell with link to univariate analysis
+                if uv_expl
+                  if uv_expl.render_charts?
+                    # Link to anchor on current page (chart is currently rendered)
+                    content_tag(
+                      :td,
+                      link_to(
+                        '⬅',
+                        "##{ uv_expl.dom_id }",
+                        class: 'btn btn-default btn-xs'
+                      ),
+                      class: 'rde_toc-currently_rendered',
+                    )
+                  else
+                    # Load new page
+                    content_tag(
+                      :td,
+                      link_to(
+                        '⬅',
+                        url_for(
+                          rde: { univariate: { '1' => uv_expl.data_series_names }},
+                          anchor: uv_expl.dom_id
+                        ),
+                        class: 'btn btn-default btn-xs'
+                      ),
+                      class: 'rde_toc-available_not_rendered'
+                    )
+                  end
+                else
+                  # show that no exploration exists
+                  content_tag(:td, 'N/A', class: 'rde_toc-not_available')
+                end +
+                # iterate over reversed data_series names
+                reversed_ds_names.map { |r_ds_name|
+                  bv_expl = explorations.detect { |e|
+                    e.dom_id == RailsDataExplorer::Exploration.compute_dom_id(
+                      [ds_name, r_ds_name]
+                    )
+                  }
+                  if encountered_bv_with_self
+                    # blank cell
+                    '<td class="rde_toc-oso_diagonal"></td>'.html_safe
+                  elsif ds_name == r_ds_name
+                    # intersection with self
+                    encountered_bv_with_self = true
+                    params_counter = '0'
+                    # Link to anchor on new page (chart is currently not rendered)
+                    content_tag(
+                      :td,
+                      link_to(
+                        image_tag('rails-data-explorer/multiple_bivariate_small.png'),
+                        url_for(
+                          rde: {
+                            univariate: { '1' => [r_ds_name] },
+                            bivariate: ds_names.each_with_object({}) { |e,m|
+                              next  if r_ds_name == e # skip bivariate with self
+                              m[params_counter.succ!] = [r_ds_name, e]
+                            }
+                          },
+                          anchor: 'rails_data_explorer-toc',
+                        ),
+                        class: 'btn btn-default btn-xs'
+                      ),
+                      class: 'rde_toc-available_not_rendered'
+                    )
+                  elsif bv_expl
+                    # bivariate analysis exists
+                    if bv_expl.render_charts?
+                      # Link to anchor on current page (chart is currently rendered)
+                      content_tag(
+                        :td,
+                        link_to(
+                          'X',
+                          "##{ bv_expl.dom_id }",
+                          class: 'btn btn-default btn-xs'
+                        ),
+                        class: 'rde_toc-currently_rendered',
+                      )
+                    else
+                      # Link to anchor on new page (chart is currently not rendered)
+                      content_tag(
+                        :td,
+                        link_to(
+                          'X',
+                          url_for(
+                            rde: { bivariate: { '1' => bv_expl.data_series_names }},
+                            anchor: bv_expl.dom_id
+                          ),
+                          class: 'btn btn-default btn-xs'
+                        ),
+                        class: 'rde_toc-available_not_rendered'
+                      )
+                    end
+                  else
+                    # show that no exploration exists
+                    content_tag(:td, 'N/A', class: 'rde_toc-not_available')
+                  end
+                }.join.html_safe
+              end
+            }.join.html_safe
+          end
+        end
+      end
+    end
+
+    def rde_explorations_with_charts(explorations)
+      explorations.map { |e| e.render }.join.html_safe
     end
 
   end

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

@@ -127,5 +127,9 @@ class RailsDataExplorer
       r << %(#{ '  ' * (indent-1) }>\n)
     end
 
+    def data_series_names
+      data_series.map { |e| e.name }
+    end
+
   end
 end

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

@@ -6,19 +6,25 @@ class RailsDataExplorer
     # 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
+    isolate_namespace RailsDataExplorer
+
+    # ActiveSupport.on_load :action_controller do
+    #   include RailsDataExplorer::ActionControllerExtension
     # end
 
-    # initializer "rails-data-explorer.action_view_extension" do |app|
-    #   require 'rails-data-explorer/action_view_extension'
-    #   class ::ActionView::Base
-    #     include RailsDataExplorer::ActionViewExtension
-    #   end
+    ActiveSupport.on_load :action_view do
+      include RailsDataExplorer::ActionViewExtension
+    end
+
+    # ActiveSupport.on_load :active_record do
+    #   extend RailsDataExplorer::ActiveRecordExtension
     # end
 
+    initializer "filterrific" do |app|
+      app.config.assets.precompile += %w(
+        multiple_bivariate_small.png
+      )
+    end
+
   end
 end

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

@@ -6,22 +6,32 @@ class RailsDataExplorer
 
     attr_accessor :charts, :data_set, :title
 
+    delegate :data_series_names, to: :data_set, prefix: false
     delegate :number_of_values, to: :data_set, prefix: false
 
+    # Computes a dom_id for data_series_names
+    # @param data_series_names [Array<String>]
+    # @return [String]
+    def self.compute_dom_id(data_series_names)
+      "rde-exploration-#{ data_series_names.sort.map { |e| e.parameterize('') }.join('-') }"
+    end
+
     # 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:
+    # @param _title [String] will be printed at top of visualization
+    # @param data_set_or_array [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
+    # @param render_charts [Boolean] set to true to render charts for this exploration
+    # @param chart_specs [Array<Chart, String, Symbol>, optional]
     #  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)
+    def initialize(_title, data_set_or_array, render_charts, chart_specs=nil)
       @title = _title
       @data_set = initialize_data_set(data_set_or_array)
+      @render_charts = render_charts
       @charts = initialize_charts(chart_specs)
     end
 
@@ -41,8 +51,13 @@ class RailsDataExplorer
       end.html_safe
     end
 
+    # Returns true if charts for this exploration are to be rendered.
+    def render_charts?
+      @render_charts
+    end
+
     def dom_id
-      "rde-exploration-#{ object_id }"
+      self.class.compute_dom_id(data_series_names)
     end
 
     def inspect(indent=1, recursive=1000)
@@ -74,6 +89,7 @@ class RailsDataExplorer
 
     def initialize_charts(chart_specs)
       if chart_specs.present?
+        raise "Handle chart_specs: #{ chart_specs.inspect }"
         chart_specs.map { |chart_spec|
           case chart_spec
           when Chart
@@ -94,7 +110,7 @@ class RailsDataExplorer
         DataSet.new(data_set_or_array, @title)
       when DataSet
         # use as is
-        _data_set
+        data_set_or_array
       else
         raise(
           ArgumentError.new(

data/lib/rails_data_explorer.rb

@@ -4,70 +4,107 @@ class RailsDataExplorer
   include ActionView::Helpers::TagHelper
 
   attr_reader :explorations
-
-  def initialize(data_collection, data_series_specs)
+  attr_reader :data_series_names
+
+  # Top level initialization. This is what you normally should use.
+  # @param data_collection [Array<Array>] Outer array is the container, inner
+  #                                       array represents each record (row of data).
+  # @param data_series_specs [Array<Hash>] One Hash for each data series.
+  # @param explorations_to_render [Hash]
+  #        {
+  #          "univariate" => {
+  #            "1" => ["Hour of day"],
+  #          },
+  #          "bivariate" => {
+  #            "1" => ["Context", "Release (major)"],
+  #            "2" => ["Year", "Timezone"],
+  #          }
+  #        }
+  def initialize(data_collection, data_series_specs, explorations_to_render)
     @explorations = []
-    univariate = []
-    bivariate = {}
-    multivariate = {}
+    charts = {
+      univariate: [],
+      bivariate: {},
+      multivariate: {}
+    }
+    @data_series_names = data_series_specs.map { |e| e[:name] }
+    # Default to all univariate explorations
+    explorations_to_render = (
+      explorations_to_render || @data_series_names.inject({ univariate: {}}) { |m,e|
+        m[:univariate][e] = [e]
+        m
+      }
+    ).symbolize_keys
 
+    # Build list of all available explorations (rendered and not rendered),
+    # grouped by type_of_analysis
     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|
+      charts[:univariate] << data_series_spec.dup
+
+      charts[:bivariate]['rde-default'] ||= []
+      charts[:bivariate]['rde-default'] << data_series_spec.dup
+
+      # No defaults for multivariate yet... Have to be specified manually via
+      # data_series specs
+      if data_series_spec[:multivariate]
+        [*data_series_spec[:multivariate]].each { |group_key|
           group_key = group_key.to_s
-          multivariate[group_key] ||= []
-          multivariate[group_key] << ds_spec.dup
+          charts[:multivariate][group_key] ||= []
+          charts[:multivariate][group_key] << data_series_spec.dup
         }
       end
+
     end
 
-    univariate.uniq.compact.each { |data_series_spec|
+    charts[:univariate].uniq.compact.each { |data_series_spec|
       @explorations << Exploration.new(
         data_series_spec[:name],
         data_collection.map(&data_series_spec[:data_method]),
+        render_exploration_for?(
+          explorations_to_render,
+          :univariate,
+          [data_series_spec[:name]]
+        )
       )
     }
 
-    bivariate.each { |group_key, bv_data_series_specs|
+    charts[: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
+          ds_specs_pair,
+          render_exploration_for?(
+            explorations_to_render,
+            :bivariate,
+            ds_specs_pair.map { |e| e[:name] }
+          )
         )
       }
     }
 
-    multivariate.each { |group_key, mv_data_series_specs|
+    charts[: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
+        ds_specs,
+        true # always render multivariate since they are specified manually
       )
     }
   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
+  def explorations_with_charts_available
+    explorations.find_all { |e| e.charts.any? }
+  end
+
+  def explorations_with_charts_to_render
+    explorations_with_charts_available.find_all { |e| e.render_charts? }
+  end
+
+  def explorations_with_no_charts_available
+    explorations.find_all { |e| e.charts.empty? }
   end
 
   def number_of_values
@@ -76,7 +113,7 @@ class RailsDataExplorer
 
 private
 
-  def build_exploration_from_data_series_specs(data_collection, ds_specs)
+  def build_exploration_from_data_series_specs(data_collection, ds_specs, render_charts)
     Exploration.new(
       ds_specs.map { |e| e[:name] }.sort.join(' vs. '),
       ds_specs.map { |ds_spec|
@@ -84,65 +121,33 @@ private
           name: ds_spec[:name],
           values: data_collection.map(&ds_spec[:data_method])
         }
-      }
+      },
+      render_charts
     )
   end
 
-  def render_toc(expls)
-    grouped_by_analysis = expls.group_by { |e| e.type_of_analysis }
-    content_tag(:div, class: 'rde panel panel-primary') do
-      content_tag(:div, class: 'panel-heading') do
-        %(<a name="rails_data_explorer-toc"></a>).html_safe +
-        content_tag(:h2, "List of data explorations", class: 'rde-exploration-title panel-title')
-      end +
-      content_tag(:div, class: 'panel-body') do
-        content_tag(:table, class: 'table') do
-          content_tag(:tr) do
-            grouped_by_analysis.map { |(label, exps)|
-              content_tag(:td, style: "width: 30%;") do
-                content_tag(:h3, label) +
-                content_tag(:ol, class: 'rde-table_of_contents') do
-                  exps.map { |expl|
-                    content_tag(
-                      :li,
-                      %(<a href="##{ expl.dom_id }">#{ expl.title }</a>).html_safe
-                    )
-                  }.join.html_safe
-                end
-              end
-            }.join.html_safe
-          end
-        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
+  # Returns true if data_series with data_series_names should have charts for
+  # explorations with type_of_analysis rendered.
+  # @param explorations_to_render [Hash]
+  #     {:bivariate=>{"rde-exploration-context-year"=>["Context", "Year"]}}
+  # @param type_of_analysis [Symbol] one of :univariate, :bivariate, :multivariate
+  # @param data_series_names [Array<String>] names of data_series to return answer for
+  # @return [Boolean]
+  def render_exploration_for?(explorations_to_render, type_of_analysis, data_series_names)
+    case type_of_analysis
+    when :univariate
+      # Return true if a :univariate exploration exists that contains data_series_names
+      (explorations_to_render[:univariate] || []).any? { |dom_id, ds_names|
+        data_series_names.sort == ds_names.sort
+      }
+    when :bivariate
+      # Return true if a :bivariate exploration exists that contains data_series_names
+      (explorations_to_render[:bivariate] || []).any? { |dom_id, ds_names|
+        data_series_names.sort == ds_names.sort
+      }
+    else
+      raise "Handle this type_of_analysis: #{ type_of_analysis.inspect }"
     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.2.2'
+  gem.version = '0.2.3'
   gem.platform = Gem::Platform::RUBY
 
   gem.authors = ['Jo Hund']

data/vendor/assets/stylesheets/sources/rde-default-style.css

@@ -40,3 +40,35 @@ td.rde-numerical {
   line-height: normal;
   text-align: right;
 }
+
+table.rde_toc-matrix.table td {
+  text-align: center;
+  vertical-align:  middle;
+}
+
+table.rde_toc-matrix.table th {
+  font-weight: normal;
+}
+
+th.rde_toc-row_header {
+  white-space: nowrap;
+  overflow-x: hidden;
+}
+
+th.rde_toc-col_header {
+  text-align: center;
+}
+
+td.rde_toc-available_not_rendered {
+}
+
+td.rde_toc-currently_rendered {
+  background-color: #cfc;
+}
+
+td.rde_toc-not_available {
+  color: #999;
+}
+
+td.rde_toc-oso_diagonal {
+}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-data-explorer
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Jo Hund
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-30 00:00:00.000000000 Z
+date: 2015-02-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: color
@@ -163,6 +163,7 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/assets/images/rails-data-explorer/multiple_bivariate_small.png
 - doc/how_to/release.md
 - doc/how_to/trouble_when_packaging_assets.md
 - doc/rails-data-explorer-screenshot.png