active_reporter 0.5.8

data/lib/active_reporter/dimension/bin.rb

@@ -0,0 +1,123 @@
+require 'active_reporter/dimension/base'
+
+module ActiveReporter
+  module Dimension
+    class Bin < Base
+      MAX_BINS = 2_000
+
+      def max_bins
+        self.class::MAX_BINS
+      end
+
+      def min
+        @min ||= filter_min || report.records.minimum(expression)
+      end
+      alias bin_start min
+
+      def max
+        @max ||= filter_max || report.records.maximum(expression)
+      end
+
+      def filter_min
+        filter_values_for(:min).min
+      end
+
+      def filter_max
+        filter_values_for(:max).max
+      end
+
+      def domain
+        min.nil? || max.nil? ? 0 : (max - min)
+      end
+
+      def group_values
+        @group_values ||= to_bins(array_param(:bins).presence || autopopulate_bins)
+      end
+
+      def filter_values
+        @filter_values ||= to_bins(super)
+      end
+
+      def filter(relation)
+        filter_values.filter(relation, expression)
+      end
+
+      def group(relation)
+        group_values.group(relation, expression, sql_value_name)
+      end
+
+      def validate_params!
+        super
+
+        if params.key?(:bin_count)
+          invalid_param!(:bin_count, "must be numeric") unless ActiveReporter.numeric?(params[:bin_count])
+          invalid_param!(:bin_count, "must be greater than 0") unless params[:bin_count].to_i > 0
+          invalid_param!(:bin_count, "must be less than #{max_bins}") unless params[:bin_count].to_i <= max_bins
+        end
+
+        if array_param(:bins).present?
+          invalid_param!(:bins, "must be hashes with min/max keys and valid values, or nil") unless group_values.all?(&:valid?)
+        end
+
+        if array_param(:only).present?
+          invalid_param!(:only, "must be hashes with min/max keys and valid values, or nil") unless filter_values.all?(&:valid?)
+        end
+      end
+
+      private
+
+      def filter_values_for(key)
+        filter_values.map { |filter_value| filter_value.send(key) }.compact
+      end
+
+      def table
+        self.class.const_get(:Table)
+      end
+
+      def set
+        self.class.const_get(:Set)
+      end
+
+      def to_bins(bins)
+        table.new(bins.map(&method(:to_bin)))
+      end
+
+      def to_bin(bin)
+        set.from_hash(bin)
+      end
+
+      def sanitize_sql_value(value)
+        set.from_sql(value)
+      end
+
+      def data_contains_nil?
+        report.records.where("#{expression} IS NULL").exists?
+      end
+
+      def autopopulate_bins
+        return [] if bin_start.blank? || max.blank?
+
+        bin_max = filter_values_for(:max).present? ? (max - bin_width) : max
+        
+        bin_count = (bin_max - bin_start)/(bin_width)
+        invalid_param!(:bin_width, "is too small for the domain; would generate #{bin_count} bins") if bin_count > max_bins
+
+        bin_edge = bin_start
+        bins = []
+
+        loop do
+          break if bin_edge > bin_max
+
+          bin = { min: bin_edge, max: bin_edge + bin_width }
+          bins << bin
+          bin_edge = bin[:max]
+        end
+
+        bins.reverse! if sort_desc?
+        ( nulls_last? ? bins.push(nil) : bins.unshift(nil) ) if data_contains_nil?
+
+        bins
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/bin/set.rb

@@ -0,0 +1,162 @@
+module ActiveReporter
+  module Dimension
+    class Bin
+      class Set
+        class << self
+          def from_hash(source)
+            # Returns either a bin or nil, depending on whether the input is valid.
+            case source
+            when nil
+              new(nil, nil)
+            when Hash then
+              min, max = source.symbolize_keys.values_at(:min, :max)
+              new(min.presence, max.presence) unless min.blank? && max.blank?
+            else
+              nil
+            end
+          end
+
+          def from_sql(value)
+            case value
+            when /^([^,]+),(.+)$/ then new($1, $2)
+            when /^([^,]+),$/     then new($1, nil)
+            when /^,(.+)$/        then new(nil, $1)
+            when ',', nil         then new(nil, nil)
+            else
+              raise "Unexpected SQL bin format #{value}"
+            end
+          end
+        end
+
+        def initialize(min, max)
+          @min = min
+          @max = max
+        end
+
+        def min
+          @min && parse(@min)
+        end
+
+        def max
+          @max && parse(@max)
+        end
+
+        def valid?
+          (@min.nil? || parses?(@min)) && (@max.nil? || parses?(@max))
+        end
+
+        def parses?(value)
+          parse(value).present? rescue false
+        end
+
+        def parse(value)
+          value
+        end
+
+        def quote(value)
+          ActiveRecord::Base.connection.quote(value)
+        end
+
+        def cast(value)
+          quote(value)
+        end
+
+        def bin_text
+          "#{min},#{max}"
+        end
+
+        def cast_bin_text
+          case ActiveReporter.database_type
+          when :postgres, :sqlite
+            "CAST(#{quote(bin_text)} AS text)"
+          else
+            quote(bin_text)
+          end
+        end
+
+        def row_sql
+          "SELECT #{cast(min)} AS min, #{cast(max)} AS max, #{cast_bin_text} AS bin_text"
+        end
+
+        def contains_sql(expr)
+          case bin_edges
+          when :min_and_max
+            "(#{expr} >= #{quote(min)} AND #{expr} < #{quote(max)})"
+          when :min
+            "#{expr} >= #{quote(min)}"
+          when :max
+            "#{expr} < #{quote(max)}"
+          else
+            "#{expr} IS NULL"
+          end
+        end
+
+        def as_json(*)
+          @as_json ||= case bin_edges
+          when :min_and_max
+            { min: min, max: max }
+          when :min
+            { min: min }
+          when :max
+            { max: max }
+          end
+        end
+
+        def [](key)
+          case key.to_s
+          when 'min' then min
+          when 'max' then max
+          end
+        end
+
+        def has_key?(key)
+          %w[min max].include?(key.to_s)
+        end
+        alias key? has_key?
+
+        def values_at(*keys)
+          keys.map { |k| self[key] }
+        end
+
+        def inspect
+          "<Bin @min=#{min.inspect} @max=#{max.inspect}>"
+        end
+
+        def hash
+          as_json.hash
+        end
+
+        def ==(other)
+          if other.nil?
+            min.nil? && max.nil?
+          else
+            min == other[:min] && max == other[:max]
+          end
+        end
+        alias eql? ==
+
+        def bin_edges
+          case 
+          when min_and_max? then :min_and_max
+          when min? then :min
+          when max? then :max
+          end
+        end
+
+        private
+
+        def min_and_max?
+          min.present? && max.present?
+        end
+
+        def min?
+          min.present?
+        end
+
+        def max?
+          max.present?
+        end
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/bin/table.rb

@@ -0,0 +1,43 @@
+module ActiveReporter
+  module Dimension
+    class Bin
+      class Table < Array
+        def initialize(values)
+          super(values.compact)
+        end
+
+        def filter(relation, expr)
+          relation.where(any_contain(expr))
+        end
+
+        def group(relation, expr, value_name)
+          name = "#{value_name}_bin_table"
+
+          bin_join = <<~SQL
+            INNER JOIN (
+              #{rows.join(" UNION\n  ")}
+            ) AS #{name} ON (
+              CASE
+              WHEN #{name}.min IS NULL AND #{name}.max IS NULL THEN (#{expr} IS NULL)
+              WHEN #{name}.min IS NULL THEN (#{expr} < #{name}.max)
+              WHEN #{name}.max IS NULL THEN (#{expr} >= #{name}.min)
+              ELSE ((#{expr} >= #{name}.min) AND (#{expr} < #{name}.max))
+              END
+            )
+          SQL
+
+          selection = "#{name}.bin_text AS #{value_name}"
+          relation.joins(bin_join).select(selection).group(value_name)
+        end
+
+        def rows
+          map(&:row_sql)
+        end
+
+        def any_contain(expr)
+          map { |bin| bin.contains_sql(expr) }.join(' OR ')
+        end
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/category.rb

@@ -0,0 +1,29 @@
+require 'active_reporter/dimension/base'
+
+module ActiveReporter
+  module Dimension
+    class Category < Base
+      def filter(relation)
+        values = filter_values
+        query = "#{expression} IN (?)"
+        query = "#{expression} IS NULL OR #{query}" if values.include?(nil)
+        relation.where(query, values.compact)
+      end
+
+      def group(relation)
+        order relation.select("#{expression} AS #{sql_value_name}").group(sql_value_name)
+      end
+
+      def group_values
+        return filter_values if filtering?
+
+        i = report.groupers.index(self)
+        report.raw_data.keys.map { |x| x[i] }.uniq
+      end
+
+      def all_values
+        relate(report.base_relation).pluck("DISTINCT #{expression}").map(&method(:sanitize_sql_value))
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/enum.rb

@@ -0,0 +1,32 @@
+require 'active_reporter/dimension/category'
+
+module ActiveReporter
+  module Dimension
+    class Enum < Category
+      def group_values
+        return filter_values if filtering?
+
+        # i = report.groupers.key(self)
+        all_values & report.raw_data.keys.map { |x| x[0] }.uniq
+      end
+
+      def all_values
+        enum_values.keys.unshift(nil)
+      end
+
+      private
+
+      def enum_values
+        model.defined_enums[attribute.to_s]
+      end
+
+      def sanitize_sql_value(value)
+        enum_values.invert[value]
+      end
+
+      def enum?
+        true # Hash(model&.defined_enums).include?(attribute.to_s)
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/number.rb

@@ -0,0 +1,51 @@
+require 'active_reporter/dimension/bin'
+
+module ActiveReporter
+  module Dimension
+    class Number < Bin
+      DEFAULT_BIN_COUNT = 10
+
+      def validate_params!
+        super
+
+        if params.key?(:bin_width)
+          invalid_param!(:bin_width, 'must be numeric') unless ActiveReporter.numeric?(params[:bin_width])
+          invalid_param!(:bin_width, 'must be greater than 0') unless params[:bin_width].to_f > 0
+        end
+      end
+
+      def bin_width
+        case
+        when params.key?(:bin_width)
+          params[:bin_width].to_f
+        when domain.zero?
+          1
+        when params.key?(:bin_count)
+          domain / params[:bin_count].to_f
+        else
+          default_bin_width
+        end
+      end
+
+      private
+
+      def default_bin_width
+        domain / default_bin_count.to_f
+      end
+
+      def default_bin_count
+        self.class::DEFAULT_BIN_COUNT
+      end
+
+      class Set < Bin::Set
+        def parses?(value)
+          ActiveReporter.numeric?(value)
+        end
+
+        def parse(value)
+          value.to_f
+        end
+      end
+    end
+  end
+end

data/lib/active_reporter/dimension/time.rb

@@ -0,0 +1,93 @@
+require 'active_reporter/inflector'
+require 'active_reporter/dimension/bin'
+
+module ActiveReporter
+  module Dimension
+    class Time < Bin
+      STEPS = %i(seconds minutes hours days weeks months years)
+      BIN_STEPS = (STEPS - [:seconds]).map { |step| step.to_s.singularize(:_gem_active_reporter) }
+      DURATION_PATTERN = /\A\d+ (?:#{STEPS.map{ |step| "#{step}?" }.join('|')})\z/
+
+      def validate_params!
+        super
+
+        invalid_param!(:bin_width, "must be a hash of one of #{STEPS} to an integer") if params.key?(:bin_width) && !valid_duration?(params[:bin_width])
+      end
+
+      def bin_width
+        @bin_width ||= case
+        when params.key?(:bin_width)
+          custom_bin_width
+        when params.key?(:bin_count) && domain > 0
+          (domain / params[:bin_count].to_f).seconds
+        else
+          default_bin_width
+        end
+      end
+
+      def bin_start
+        # ensure that each autogenerated bin represents a correctly aligned
+        # day/week/month/year
+        bin_start = super
+        
+        return if bin_start.nil?
+
+        step = BIN_STEPS.detect { |step| bin_width == 1.send(step) }
+        step.present? ? bin_start.send(:"beginning_of_#{step}") : bin_start
+      end
+
+      private
+
+      def custom_bin_width
+        case params[:bin_width]
+        when Hash
+          params[:bin_width].map { |step, n| n.send(step) }.sum
+        when String
+          n, step = params[:bin_width].split.map(&:strip)
+          n.to_i.send(step)
+        end
+      end
+
+      def valid_duration?(d)
+        case d
+        when Hash
+          d.all? { |step, n| step.to_sym.in?(STEPS) && n.is_a?(Numeric) }
+        when String
+          d =~ DURATION_PATTERN
+        else
+          false
+        end
+      end
+
+      def default_bin_width
+        case domain
+        when 0 then 1.day
+        when 0..1.minute then 1.second
+        when 0..2.hours then 1.minute
+        when 0..2.days then 1.hour
+        when 0..2.weeks then 1.day
+        when 0..2.months then 1.week
+        when 0..2.years then 1.month
+        else 1.year
+        end
+      end
+
+      class Set < Bin::Set
+        def parse(value)
+          ::Time.zone.parse(value.to_s.gsub('"', ''))
+        end
+
+        def cast(value)
+          case ActiveReporter.database_type
+          when :postgres
+            "CAST(#{super} AS timestamp with time zone)"
+          when :sqlite
+            "DATETIME(#{super})"
+          else
+            "CAST(#{super} AS DATETIME)"
+          end
+        end
+      end
+    end
+  end
+end