active_reporter 0.5.8

data/lib/active_reporter/serializer/csv.rb

@@ -0,0 +1,22 @@
+require 'csv'
+
+module ActiveReporter
+  module Serializer
+    class Csv < Table
+      def csv_text
+        CSV.generate do |csv|
+          csv << headers
+          each_row { |row| csv << row }
+        end
+      end
+
+      def save(filename = self.filename)
+        File.open(filename, 'w') { |f| f.write data }
+      end
+
+      def filename
+        "#{caption.parameterize}.csv"
+      end
+    end
+  end
+end

data/lib/active_reporter/serializer/form_field.rb

@@ -0,0 +1,134 @@
+module ActiveReporter
+  module Serializer
+    class FormField < Base
+      include ActionView::Helpers::FormTagHelper
+      include ActionView::Helpers::FormOptionsHelper
+
+      def html_fields
+        "<div class='#{wrapper_class}'>
+          #{axis_fields}
+          #{dimension_fields.join}
+        </div>".html_safe
+      end
+
+      def aggregator_options
+        @agg_opts ||= report.aggregators.map { |name, agg| [human_aggregator_label(agg), name] }
+      end
+
+      def dimension_options
+        @dim_opts ||= report.dimensions.map { |name, dim| [human_dimension_label(dim), name] }
+      end
+
+      def aggregator_field
+        select_tag("#{prefix}[aggregator]", options_for_select(aggregator_options, report.aggregators.keys.first))
+      end
+
+      def primary_grouper_field
+        select_tag("#{prefix}[groupers][0]", options_for_select(dimension_options, report.grouper_names[0]))
+      end
+
+      def secondary_grouper_field
+        select_tag("#{prefix}[groupers][1]", options_for_select([[nil, nil]]+dimension_options, report.grouper_names[1]))
+      end
+
+      def axis_fields
+        "<div class='#{axis_fields_class}'>
+          Show me #{aggregator_field}
+          by #{primary_grouper_field}
+          and #{secondary_grouper_field}
+          for
+        </div>".html_safe
+      end
+
+      def dimension_fields
+        report.dimensions.map { |name, dimension| field_for(dimension) }.compact
+      end
+
+      def field_for(dimension)
+        case dimension
+        when ActiveReporter::Dimension::Category then category_dimension_field(dimension)
+        when ActiveReporter::Dimension::Set then bin_dimension_field(dimension)
+        end
+      end
+
+      def category_dimension_field(dimension)
+        options = [[nil, nil]]
+
+        dimension.all_values.each do |value|
+          options << [human_dimension_value_label(dimension, value), value]
+        end
+
+        fields_for(dimension) do
+          select_tag("#{prefix_for(dimension)}[only]", options_for_select(options, dimension.filter_values.first))
+        end
+      end
+
+      def bin_dimension_field(dimension)
+        fields_for(dimension) do
+          fields = "#{bin_min_field(dimension)} to #{bin_max_field(dimension)}"
+          fields += " by #{bin_step_field(dimension)}" if dimension.grouping?
+          fields
+        end
+      end
+
+      def bin_min_field(dimension)
+        text_field_tag("#{prefix_for(dimension)}[only][min]", dimension.filter_min, placeholder: bin_min_placeholder(dimension))
+      end
+
+      def bin_max_field(dimension)
+        text_field_tag("#{prefix_for(dimension)}[only][max]", dimension.filter_max, placeholder: bin_max_placeholder(dimension))
+      end
+
+      def bin_step_field(dimension)
+        text_field_tag("#{prefix_for(dimension)}[bin_width]", dimension.params[:bin_width], placeholder: bin_step_placeholder(dimension))
+      end
+
+      def fields_for(dimension, &block)
+        "<fieldset class='#{dimension_fields_class(dimension)}'>
+          <legend>#{human_dimension_label(dimension)}</legend>
+          #{yield}
+        </fieldset>".html_safe
+      end
+
+      def wrapper_class
+        "active-reporter-fields active-reporter-fields--#{css_class(report.class.name)}"
+      end
+
+      def axis_fields_class
+        'active-reporter-axis-fields'
+      end
+
+      def dimension_fields_class(dimension)
+        [
+          'active-reporter-dimension-fields',
+          "active-reporter-dimension-fields--#{css_class(dimension.name)}",
+          "active-reporter-dimension-fields--#{css_class(dimension.class.name)}"
+        ].join(' ')
+      end
+
+      def bin_max_placeholder(dimension)
+        'max'
+      end
+
+      def bin_min_placeholder(dimension)
+        'min'
+      end
+
+      def bin_step_placeholder(dimension)
+        dimension.bin_width.inspect
+      end
+
+      def prefix
+        report.class.name.underscore
+      end
+
+      def prefix_for(dimension)
+        "#{prefix}[dimensions][#{dimension.name}]"
+      end
+
+      def css_class(s)
+        s.to_s.demodulize.underscore.dasherize
+      end
+    end
+  end
+end

data/lib/active_reporter/serializer/hash_table.rb

@@ -0,0 +1,12 @@
+module ActiveReporter
+  module Serializer
+    class HashTable < Base
+      def table
+        fields = (report.grouper_names + report.aggregators.keys)
+        titles = report.groupers.map(&method(:human_dimension_label)) + report.aggregators.collect { |k, v| human_aggregator_label({ k => v }) }
+
+        [fields.zip(titles).to_h] + report.hashed_data.collect { |row| row.map { |k,v| [k, (v.respond_to?(:min) ? v.min : v).to_s] }.to_h}
+      end
+    end
+  end
+end

data/lib/active_reporter/serializer/highcharts.rb

@@ -0,0 +1,200 @@
+module ActiveReporter
+  module Serializer
+    class Highcharts < Table
+      def colors
+        ['#7cb5ec', '#434348', '#90ed7d', '#f7a35c', '#8085e9', '#f15c80', '#e4d354', '#2b908f', '#f45b5b', '#91e8e1']
+      end
+
+      def color_hash
+        # ensure we consistently assign the same color to the same dimension-
+        # value pair
+        @color_hash ||= Hash.new do |h, key|
+          color_cycle = colors.cycle
+          h[key] = Hash.new do |hh, value|
+            hh[value] = color_cycle.next
+          end
+        end
+      end
+
+      def color_for(dimension, value)
+        # override this if the values of a particular dimension can take on
+        # meaningful colors
+        color_hash[dimension.name][value]
+      end
+
+      # def series
+      #   case report.groupers.count
+      #   when 2
+      #     dim1, dim2 = report.groupers
+      #     report.data.flat_map.with_index do |d2, i|
+      #       d2[:values].map do |d1|
+      #         {
+      #           stack: human_dimension_value_label(dim2, d2[:key]),
+      #           name: human_dimension_value_label(dim1, d1[:key]),
+      #           (i == 0 ? :id : :linkedTo) => human_dimension_value_label(dim1, d1[:key]),
+      #           color: color_for(dim1, d1[:key]),
+      #           data: d1[:values].map do |k,v|
+      #             {
+      #               y: v.to_f,
+      #               tooltip: tooltip_for(k => v, dim1 => d1),
+      #               filters: filters_for(k => v, dim1 => d1)
+      #             }
+      #           end
+      #         }
+      #       end
+      #     end
+      #   when 1
+      #     dim1 = report.groupers.first
+      #     report.data.map do |d1|
+      #       {
+      #         name: human_dimension_value_label(dim1, d1[:key]),
+      #         color: color_for(dim1, d1[:key]),
+      #         data: d1[:values].map do |k,v|
+      #           {
+      #             y: v.to_f,
+      #             tooltip: tooltip_for(k => v, dim1 => d1),
+      #             filters: filters_for(k => v, dim1 => d1)
+      #           }
+      #         end
+      #       }
+      #     end
+      #   else
+      #     raise ActiveReporter::InvalidParamsError, "report must have <= 2 groupers"
+      #   end
+      # end
+
+      def series
+        case report.groupers.count
+        when 3
+          dim1, dim2, dim3 = report.groupers
+          report.data.flat_map.with_index do |d3, i|
+            d3[:values].map { |d2| {
+              stack: human_dimension_value_label(dim3, d3[:key]),
+              name: human_dimension_value_label(dim2, d2[:key]),
+              (i == 0 ? :id : :linkedTo) => human_dimension_value_label(dim2, d2[:key]),
+              color: color_for(dim2, d2[:key]),
+              data: d2[:values].map { |d1| {
+                y: d1[:value].to_f,
+                tooltip: tooltip_for(dim1 => d1, dim2 => d2, dim3 => d3),
+                filters: filters_for(dim1 => d1, dim2 => d2, dim3 => d3)
+              }}
+            }}
+          end
+        when 2
+          dim1, dim2 = report.groupers
+          report.data.map { |d2| {
+            name: human_dimension_value_label(dim2, d2[:key]),
+            color: color_for(dim2, d2[:key]),
+            data: d2[:values].map { |d1| {
+              y: d1[:value].to_f,
+              tooltip: tooltip_for(dim1 => d1, dim2 => d2),
+              filters: filters_for(dim1 => d1, dim2 => d2)
+            }}
+          }}
+        when 1
+          dim1 = report.groupers.first
+          [{
+            name: human_aggregator_label(report.aggregators),
+            data: report.data.map { |d1| {
+              y: d1[:value].to_f,
+              tooltip: tooltip_for(dim1 => d1),
+              filters: filters_for(dim1 => d1)
+            }}
+          }]
+        else
+          raise ActiveReporter::InvalidParamsError, "report must have <= 3 groupers"
+        end
+      end
+
+      def tooltip_for(xes)
+        lines = []
+        xes.each do |dim, d|
+          lines << [
+            human_dimension_label(dim),
+            human_dimension_value_label(dim, d[:key])
+          ]
+        end
+        lines << [
+          human_aggregator_label(report.aggregators),
+          human_aggregator_value_label(report.aggregators, xes[report.groupers.first][:value])
+        ]
+        lines.map { |k, v| "<b>#{k}:</b> #{v}" }.join('<br/>')
+      end
+
+      def filters_for(xes)
+        xes.each_with_object({}) do |(dim, d), h|
+          h[dim.name] = d[:key]
+        end
+      end
+
+      def categories
+        dimension = report.groupers.first
+        dimension.group_values.map do |value|
+          human_dimension_value_label(dimension, value)
+        end
+      end
+
+      def chart_title
+        axis_summary
+      end
+
+      def chart_subtitle
+        filter_summary
+      end
+
+      def x_axis_title
+        human_dimension_label(report.groupers.first)
+      end
+
+      def y_axis_title
+        human_aggregator_label(report.aggregators)
+      end
+
+      def highcharts_options
+        {
+          chart: {
+            type: 'column'
+          },
+          colors: colors,
+          title: {
+            text: chart_title
+          },
+          subtitle: {
+            text: chart_subtitle
+          },
+          series: series,
+          xAxis: {
+            categories: categories,
+            title: {
+              text: x_axis_title
+            }
+          },
+          yAxis: {
+            allowDecimals: true,
+            title: {
+              text: y_axis_title
+            },
+            stackLabels: {
+              enabled: report.groupers.length >= 3,
+              format: '{stack}',
+              rotation: -45,
+              textAlign: 'left'
+            }
+          },
+          legend: {
+            enabled: report.groupers.length >= 2
+          },
+          tooltip: {},
+          plotOptions: {
+            series: {
+              events: {}
+            },
+            column: {
+              stacking: ('normal' if report.groupers.length >= 2)
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/lib/active_reporter/serializer/nested_hash.rb

@@ -0,0 +1,11 @@
+module ActiveReporter
+  module Serializer
+    class NestedHash < Base
+      def table
+        report.hashed_data.collect { |row| row.map { |k,v| [k, (v.respond_to?(:min) ? v.min : v).to_s] }.to_h }.collect do |row|
+          report.grouper_names.reverse.inject(row.slice(*report.aggregators.keys)) { |nested_row_data, group| { row[group] => nested_row_data } }
+        end.reduce({}, :merge)
+      end
+    end
+  end
+end

data/lib/active_reporter/serializer/table.rb

@@ -0,0 +1,21 @@
+module ActiveReporter
+  module Serializer
+    class Table < Base
+      def headers
+        report.groupers.map(&method(:human_dimension_label)) + [human_aggregator_label(report.aggregators)]
+      end
+
+      def each_row
+        return to_enum(__method__) unless block_given?
+
+        report.flat_data.each do |xes, y|
+          yield report.groupers.zip(xes).map { |d, v| human_dimension_value_label(d, v) } + [human_aggregator_value_label(report.aggregators, y)]
+        end
+      end
+
+      def caption
+        axis_summary
+      end
+    end
+  end
+end

data/lib/active_reporter/tracker.rb

@@ -0,0 +1,2 @@
+require 'active_reporter/tracker/base'
+require 'active_reporter/tracker/delta'

data/lib/active_reporter/tracker/base.rb

@@ -0,0 +1,15 @@
+require 'active_reporter/aggregator/base'
+
+module ActiveReporter
+  module Tracker
+    class Base < ActiveReporter::Aggregator::Base
+      def aggregator
+        opts[:aggregator] || name
+      end
+
+      def prior_aggregator
+        opts[:prior_aggregator] || aggregator
+      end
+    end
+  end
+end

data/lib/active_reporter/tracker/delta.rb

@@ -0,0 +1,9 @@
+module ActiveReporter
+  module Tracker
+    class Delta < ActiveReporter::Tracker::Base
+      def track(row, prior_row)
+        ((row[aggregator].to_f / prior_row[prior_aggregator].to_f) * 100) unless row.nil? || prior_row.nil? || prior_row[prior_aggregator].to_f == 0
+      end
+    end
+  end
+end

data/lib/active_reporter/version.rb

@@ -0,0 +1,3 @@
+module ActiveReporter
+  VERSION = "0.5.8"
+end

data/lib/tasks/active_reporter_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :active_reporter do
+#   # Task goes here
+# end