active_reporter 0.5.8

data/Rakefile

@@ -0,0 +1,23 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActiveReporter'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/active_reporter.rb

@@ -0,0 +1,26 @@
+module ActiveReporter
+  class << self
+    def database_type
+      @database_type ||= case database_adapter
+      when /postgres/ then :postgres
+      when /mysql/ then :mysql
+      when /sqlite/ then :sqlite
+      else
+        raise "unsupported database #{database_adapter}"
+      end
+    end
+
+    def numeric?(value)
+      value.is_a?(Numeric) || value.is_a?(String) && value =~ /\A\d+(?:\.\d+)?\z/
+    end
+
+    private
+
+    def database_adapter
+      ActiveRecord::Base.connection_config[:adapter]
+    end
+  end
+end
+
+require 'deeply_enumerable'
+Dir.glob(File.join(__dir__, 'active_reporter', '*/')).each { |file| require file.chomp('/') }

data/lib/active_reporter/aggregator.rb

@@ -0,0 +1,9 @@
+require 'active_reporter/aggregator/base'
+require 'active_reporter/aggregator/array'
+require 'active_reporter/aggregator/average'
+require 'active_reporter/aggregator/count'
+require 'active_reporter/aggregator/count_if'
+require 'active_reporter/aggregator/max'
+require 'active_reporter/aggregator/min'
+require 'active_reporter/aggregator/ratio'
+require 'active_reporter/aggregator/sum'

data/lib/active_reporter/aggregator/array.rb

@@ -0,0 +1,14 @@
+module ActiveReporter
+  module Aggregator
+    class Array < ActiveReporter::Aggregator::Base
+      def aggregate(groups)
+        fail InvalidParamsError, 'array agg is only supported in Postgres' unless ActiveReporter.database_type == :postgres
+        super
+      end
+
+      def function
+        "ARRAY_AGG(#{expression})"
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/average.rb

@@ -0,0 +1,9 @@
+module ActiveReporter
+  module Aggregator
+    class Average < ActiveReporter::Aggregator::Base
+      def function
+        "AVG(#{expression})"
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/base.rb

@@ -0,0 +1,73 @@
+module ActiveReporter
+  module Aggregator
+    class Base
+      attr_reader :name, :report, :opts
+
+      def initialize(name, report, opts={})
+        @name = name
+        @report = report
+        @opts = opts
+        validate_params!
+      end
+
+      def sql_value_name
+        "_report_aggregator_#{name}"
+      end
+
+      def default_value
+        opts.fetch(:default_value, nil)
+      end
+
+      def aggregate(groups)
+        relate(groups).select("#{function} AS #{sql_value_name}")
+      end
+
+      private
+
+      def validate_params!
+        if opts.include?(:expression)
+          ActiveSupport::Deprecation.warn("passing an :expression option will be deprecated in version 1.0\n  please use :attribute, and, when required, :model or :table_name")
+        end
+      end
+
+      def relate(groups)
+        relation.call(groups)
+      end
+
+      def relation
+        opts.fetch(:relation, ->(r) { r })
+      end
+
+      def model
+        opts.fetch(:model, report.report_model)
+      end
+
+      def attribute
+        opts.fetch(:attribute, name)
+      end
+
+      def table_name
+        return @table_name unless @table_name.nil?
+
+        @table_name = opts[:table_name]
+        @table_name = model.try(:table_name) if @table_name.nil?
+        @table_name = model.to_s.constantize.try(:table_name) rescue nil if @table_name.nil?
+        @table_name = report.table_name if @table_name.nil?
+
+        @table_name
+      end
+
+      def column
+        opts.fetch(:column, attribute)
+      end
+
+      def expression
+        opts.fetch(:expression, "#{table_name}.#{column}")
+      end
+
+      def enum?
+        false # Hash(model&.defined_enums).include?(attribute.to_s)
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/count.rb

@@ -0,0 +1,23 @@
+module ActiveReporter
+  module Aggregator
+    class Count < ActiveReporter::Aggregator::Base
+      def function
+        "COUNT(#{'DISTINCT' if distinct} #{expression})"
+      end
+
+      def default_value
+        super || 0
+      end
+
+      private
+
+      def distinct
+        opts[:distinct] || true
+      end
+
+      def column
+        opts.fetch(:column, 'id')
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/count_if.rb

@@ -0,0 +1,23 @@
+module ActiveReporter
+  module Aggregator
+    class CountIf < ActiveReporter::Aggregator::Count
+      def function
+        "COUNT(#{expression} IN (#{values.map(&:to_s).join(',')}) OR NULL)"
+      end
+
+      def default_value
+        super || 0
+      end
+
+      private
+
+      def values
+        Array(opts[:values] || opts[:value] || true).compact
+      end
+
+      def column
+        super || 'id'
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/max.rb

@@ -0,0 +1,9 @@
+module ActiveReporter
+  module Aggregator
+    class Max < ActiveReporter::Aggregator::Base
+      def function
+        "MAX(#{expression})"
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/min.rb

@@ -0,0 +1,9 @@
+module ActiveReporter
+  module Aggregator
+    class Min < ActiveReporter::Aggregator::Base
+      def function
+        "MIN(#{expression})"
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/ratio.rb

@@ -0,0 +1,23 @@
+module ActiveReporter
+  module Aggregator
+    class Ratio < ActiveReporter::Aggregator::Base
+      attr_reader :numerator, :denominator
+
+      def function
+        "(#{numerator}/NULLIF(#{denominator},0))"
+      end
+
+      private
+
+      def numerator
+        raise "Ratio aggregator must specify a numerator column" unless opts.include?(:numerator)
+        @numerator = report.aggregators[opts[:numerator].to_sym].try(:function) || "#{report.table_name}.#{opts[:numerator]}"
+      end
+
+      def denominator
+        raise "Ratio aggregator must specify a denominator column" unless opts.include?(:denominator)
+        @denominator = report.aggregators[opts[:denominator].to_sym].try(:function) || "#{report.table_name}.#{opts[:denominator]}"
+      end
+    end
+  end
+end

data/lib/active_reporter/aggregator/sum.rb

@@ -0,0 +1,13 @@
+module ActiveReporter
+  module Aggregator
+    class Sum < ActiveReporter::Aggregator::Base
+      def function
+        "SUM(#{expression})"
+      end
+
+      def default_value
+        super || 0
+      end
+    end
+  end
+end

data/lib/active_reporter/calculator.rb

@@ -0,0 +1,2 @@
+require 'active_reporter/calculator/base'
+require 'active_reporter/calculator/ratio'

data/lib/active_reporter/calculator/base.rb

@@ -0,0 +1,19 @@
+require 'active_reporter/aggregator/base'
+
+module ActiveReporter
+  module Calculator
+    class Base < ActiveReporter::Aggregator::Base
+      def aggregator
+        opts[:aggregator] || name
+      end
+
+      def parent_aggregator
+        opts[:parent_aggregator] || aggregator
+      end
+
+      def totals?
+        !!opts[:totals]
+      end
+    end
+  end
+end

data/lib/active_reporter/calculator/ratio.rb

@@ -0,0 +1,9 @@
+module ActiveReporter
+  module Calculator
+    class Ratio < ActiveReporter::Calculator::Base
+      def calculate(row, parent_row)
+        ((row[aggregator].to_f / parent_row[parent_aggregator].to_f) * 100) unless parent_row[parent_aggregator].to_f.zero?
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension.rb

@@ -0,0 +1,8 @@
+require 'active_reporter/dimension/base'
+require 'active_reporter/dimension/bin'
+require 'active_reporter/dimension/bin/set'
+require 'active_reporter/dimension/bin/table'
+require 'active_reporter/dimension/time'
+require 'active_reporter/dimension/number'
+require 'active_reporter/dimension/category'
+require 'active_reporter/dimension/enum'

data/lib/active_reporter/dimension/base.rb

@@ -0,0 +1,150 @@
+module ActiveReporter
+  module Dimension
+    class Base
+      attr_reader :name, :report, :opts
+
+      def initialize(name, report, opts={})
+        @name = name
+        @report = report
+        @opts = opts
+        validate_params!
+      end
+
+      def model
+        return @model unless @model.nil?
+
+        @model = opts[:model].to_s.classify.constantize rescue opts[:model]
+        @model = report.report_model if @model.nil?
+
+        @model
+      end
+
+      def attribute
+        opts.fetch(:attribute, name)
+      end
+
+      def expression
+        @expression ||= opts[:expression] || opts[:_expression] || "#{table_name}.#{column}"
+      end
+
+      # Do any joins/selects necessary to filter or group the relation.
+      def relate(relation)
+        opts.fetch(:relation, ->(r) { r }).call(relation)
+      end
+
+      # Filter the relation based on any constraints in the params
+      def filter(relation)
+        raise NotImplementedError
+      end
+
+      # Group the relation by the expression -- ensure this is ordered, too.
+      def group(relation)
+        raise NotImplementedError
+      end
+
+      # Return an ordered array of all values that should appear in `Report#data`
+      def group_values
+        raise NotImplementedError
+      end
+
+      # Given a single (hashified) row of the SQL result, return the Ruby
+      # object representing this dimension's value
+      def extract_sql_value(row)
+        sanitize_sql_value(row[sql_value_name])
+      end
+
+      def filter_values
+        array_param(:only).uniq
+      end
+
+      # Return whether the report should filter by this dimension
+      def filtering?
+        filter_values.present?
+      end
+
+      def grouping?
+        report.groupers.include?(self)
+      end
+
+      def order_expression
+        sql_value_name
+      end
+
+      def order(relation)
+        relation.order("#{order_expression} #{sort_order} #{null_order}")
+      end
+
+      def sort_desc?
+        dimension_or_root_param(:sort_desc)
+      end
+
+      def sort_order
+        sort_desc? ? 'DESC' : 'ASC'
+      end
+
+      def nulls_last?
+        value = dimension_or_root_param(:nulls_last)
+        value = !value if sort_desc?
+        value
+      end
+
+      def null_order
+        return unless ActiveReporter.database_type == :postgres
+        nulls_last? ? 'NULLS LAST' : 'NULLS FIRST'
+      end
+
+      def params
+        report.params.fetch(:dimensions, {})[name].presence || {}
+      end
+
+      private
+
+      def validate_params!
+        if opts.include?(:expression)
+          ActiveSupport::Deprecation.warn("passing an :expression option will be deprecated in version 1.0\n  please use :attribute, and, when required, :model or :table_name")
+        end
+      end
+
+      def invalid_param!(param_key, message)
+        raise InvalidParamsError, "Invalid value for params[:dimensions] [:#{name}][:#{param_key}]: #{message}"
+      end
+
+      def table_name
+        return @table_name unless @table_name.nil?
+
+        @table_name = opts[:table_name]
+        @table_name = model.try(:table_name) if @table_name.nil?
+        @table_name = model.to_s.constantize.try(:table_name) rescue nil if @table_name.nil?
+        @table_name = report.table_name if @table_name.nil?
+
+        @table_name
+      end
+
+      def column
+        opts.fetch(:column, attribute)
+      end
+
+      def sql_value_name
+        "_active_reporter_dimension_#{name}"
+      end
+
+      def sanitize_sql_value(value)
+        value
+      end
+
+      def dimension_or_root_param(key)
+        params.fetch(key, report.params[key])
+      end
+
+      def array_param(key)
+        return [] unless params.key?(key)
+        return [nil] if params[key].nil?
+        Array.wrap(params[key])
+      end
+
+      def enum?
+        false # Hash(model&.defined_enums).include?(attribute.to_s)
+      end
+    end
+  end
+end