reports_kit 0.2.0 → 0.3.0

data/lib/reports_kit/reports/data/populate_one_dimension.rb

@@ -2,33 +2,51 @@ module ReportsKit
   module Reports
     module Data
       class PopulateOneDimension
-        attr_accessor :sparse_measures_dimension_keys_values
+        attr_accessor :sparse_serieses_dimension_keys_values, :context_record, :properties
 
-        def initialize(sparse_measures_dimension_keys_values)
-          self.sparse_measures_dimension_keys_values = sparse_measures_dimension_keys_values
+        def initialize(sparse_serieses_dimension_keys_values, context_record: nil, properties: nil)
+          self.sparse_serieses_dimension_keys_values = sparse_serieses_dimension_keys_values
+          self.context_record = context_record
+          self.properties = properties
         end
 
         def perform
-          return sparse_measures_dimension_keys_values if sparse_measures_dimension_keys_values.length == 1
-          measures_dimension_keys_values
+          return sparse_serieses_dimension_keys_values if sparse_serieses_dimension_keys_values.length == 1
+          serieses_dimension_keys_values
         end
 
         private
 
-        def measures_dimension_keys_values
-          measures_dimension_keys_values = sparse_measures_dimension_keys_values.map do |measure, dimension_keys_values|
+        def serieses_dimension_keys_values
+          serieses_dimension_keys_values = sparse_serieses_dimension_keys_values.map do |series, dimension_keys_values|
             dimension_keys.each do |key|
               dimension_keys_values[key] ||= 0
             end
-            [measure, dimension_keys_values]
+            [series, dimension_keys_values]
           end
-          Hash[measures_dimension_keys_values]
+          Hash[serieses_dimension_keys_values]
         end
 
         def dimension_keys
-          sparse_measures_dimension_keys_values.map do |measure, dimension_keys_values|
-            dimension_keys_values.keys
-          end.reduce(&:+).uniq
+          dimension_keys_from_edit_dimension_keys_method || dimension_keys_from_results
+        end
+
+        def dimension_keys_from_edit_dimension_keys_method
+          return unless edit_dimension_keys_method
+          edit_dimension_keys_method.call(dimension_keys: dimension_keys_from_results, properties: properties, context_record: context_record)
+        end
+
+        def dimension_keys_from_results
+          @dimension_keys_from_results ||= begin
+            sparse_serieses_dimension_keys_values.map do |series, dimension_keys_values|
+              dimension_keys_values.keys
+            end.reduce(&:+).uniq
+          end
+        end
+
+        def edit_dimension_keys_method
+          return unless properties
+          ReportsKit.configuration.custom_method(properties[:report_options].try(:[], :edit_dimension_keys_method))
         end
       end
     end

data/lib/reports_kit/reports/data/populate_two_dimensions.rb

@@ -2,25 +2,25 @@ module ReportsKit
   module Reports
     module Data
       class PopulateTwoDimensions
-        attr_accessor :measures, :dimension, :second_dimension, :sparse_measures_dimension_keys_values
+        attr_accessor :serieses, :dimension, :second_dimension, :sparse_serieses_dimension_keys_values
 
-        def initialize(sparse_measures_dimension_keys_values)
-          self.measures = sparse_measures_dimension_keys_values.keys
-          self.dimension = measures.first.dimensions[0]
-          self.second_dimension = measures.first.dimensions[1]
-          self.sparse_measures_dimension_keys_values = sparse_measures_dimension_keys_values
+        def initialize(sparse_serieses_dimension_keys_values)
+          self.serieses = sparse_serieses_dimension_keys_values.keys
+          self.dimension = serieses.first.dimensions[0]
+          self.second_dimension = serieses.first.dimensions[1]
+          self.sparse_serieses_dimension_keys_values = sparse_serieses_dimension_keys_values
         end
 
         def perform
-          measures_populated_dimension_keys_values
+          serieses_populated_dimension_keys_values
         end
 
         private
 
-        def measures_populated_dimension_keys_values
-          measures_dimension_keys_values = {}
+        def serieses_populated_dimension_keys_values
+          serieses_dimension_keys_values = {}
           secondary_keys_sums = Hash.new(0)
-          measures_populated_primary_keys_secondary_keys_values.each do |measure, primary_keys_secondary_keys_values|
+          serieses_populated_primary_keys_secondary_keys_values.each do |series, primary_keys_secondary_keys_values|
             primary_keys_secondary_keys_values.each do |primary_key, secondary_keys_values|
               secondary_keys_values.each do |secondary_key, value|
                 secondary_keys_sums[secondary_key] += value
@@ -28,55 +28,55 @@ module ReportsKit
             end
           end
           sorted_secondary_keys = secondary_keys_sums.sort_by(&:last).reverse.map(&:first)
-          measures_populated_primary_keys_secondary_keys_values.each do |measure, primary_key_secondary_keys_values|
-            measures_dimension_keys_values[measure] = {}
+          serieses_populated_primary_keys_secondary_keys_values.each do |series, primary_key_secondary_keys_values|
+            serieses_dimension_keys_values[series] = {}
             primary_key_secondary_keys_values.each do |primary_key, secondary_keys_values|
               secondary_keys_values = secondary_keys_values.sort_by { |key, _| sorted_secondary_keys.index(key) }
               secondary_keys_values.each do |secondary_key, value|
                 dimension_key = [primary_key, secondary_key]
-                measures_dimension_keys_values[measure][dimension_key] = value
+                serieses_dimension_keys_values[series][dimension_key] = value
                 secondary_keys_sums[secondary_key] += value
               end
             end
           end
-          measures_dimension_keys_values
+          serieses_dimension_keys_values
         end
 
-        def measures_populated_primary_keys_secondary_keys_values
+        def serieses_populated_primary_keys_secondary_keys_values
           @populated_dimension_keys_values ||= begin
-            measures_populated_primary_keys_secondary_keys_values = {}
-            measures.each do |measure|
-              measures_populated_primary_keys_secondary_keys_values[measure] = {}
+            serieses_populated_primary_keys_secondary_keys_values = {}
+            serieses.each do |series|
+              serieses_populated_primary_keys_secondary_keys_values[series] = {}
               primary_keys.each do |primary_key|
-                measures_populated_primary_keys_secondary_keys_values[measure][primary_key] = {}
+                serieses_populated_primary_keys_secondary_keys_values[series][primary_key] = {}
                 secondary_keys.each do |secondary_key|
-                  value = measures_primary_keys_secondary_keys_values[measure][primary_key].try(:[], secondary_key) || 0
-                  measures_populated_primary_keys_secondary_keys_values[measure][primary_key][secondary_key] = value
+                  value = serieses_primary_keys_secondary_keys_values[series][primary_key].try(:[], secondary_key) || 0
+                  serieses_populated_primary_keys_secondary_keys_values[series][primary_key][secondary_key] = value
                 end
               end
             end
-            measures_populated_primary_keys_secondary_keys_values
+            serieses_populated_primary_keys_secondary_keys_values
           end
         end
 
-        def measures_primary_keys_secondary_keys_values
-          @measures_primary_keys_secondary_keys_values ||= begin
-            measures_primary_keys_secondary_keys_values = {}
-            sparse_measures_dimension_keys_values.each do |measure, dimension_keys_values|
-              measures_primary_keys_secondary_keys_values[measure] = {}
+        def serieses_primary_keys_secondary_keys_values
+          @serieses_primary_keys_secondary_keys_values ||= begin
+            serieses_primary_keys_secondary_keys_values = {}
+            sparse_serieses_dimension_keys_values.each do |series, dimension_keys_values|
+              serieses_primary_keys_secondary_keys_values[series] = {}
               dimension_keys_values.each do |(primary_key, secondary_key), value|
                 primary_key = primary_key.to_date if primary_key.is_a?(Time)
                 secondary_key = secondary_key.to_date if secondary_key.is_a?(Time)
-                measures_primary_keys_secondary_keys_values[measure][primary_key] ||= {}
-                measures_primary_keys_secondary_keys_values[measure][primary_key][secondary_key] = value
+                serieses_primary_keys_secondary_keys_values[series][primary_key] ||= {}
+                serieses_primary_keys_secondary_keys_values[series][primary_key][secondary_key] = value
               end
             end
-            measures_primary_keys_secondary_keys_values
+            serieses_primary_keys_secondary_keys_values
           end
         end
 
         def dimension_keys
-          @dimension_keys ||= sparse_measures_dimension_keys_values.values.map(&:keys).reduce(&:+).uniq
+          @dimension_keys ||= sparse_serieses_dimension_keys_values.values.map(&:keys).reduce(&:+).uniq
         end
 
         def primary_keys

data/lib/reports_kit/reports/data/utils.rb

@@ -2,14 +2,18 @@ module ReportsKit
   module Reports
     module Data
       class Utils
-        def self.format_display_time(time)
-          time.strftime('%b %-d, \'%y')
-        end
-
         def self.format_configuration_time(time)
           time.strftime('%b %-d, %Y')
         end
 
+        def self.format_csv_time(time)
+          time.strftime('%Y-%m-%d')
+        end
+
+        def self.format_display_time(time)
+          time.strftime('%b %-d, \'%y')
+        end
+
         def self.format_time_value(value)
           time = RelativeTime.parse(value, prevent_exceptions: true)
           return value unless time
@@ -22,17 +26,19 @@ module ReportsKit
           number.round(Generate::ROUND_PRECISION)
         end
 
+        def self.quote_column_name(string)
+          ActiveRecord::Base.connection.quote_column_name(string)
+        end
+
         def self.parse_date_string(string)
-          begin
-            Date.parse(string)
-          rescue ArgumentError
-            RelativeTime.parse(string)
-          end
+          Date.parse(string)
+        rescue ArgumentError
+          RelativeTime.parse(string)
         end
 
         def self.populate_sparse_hash(hash, dimension:)
           keys = hash.keys
-          is_nested = dimension.measure.has_two_dimensions?
+          is_nested = dimension.series.has_two_dimensions?
           if is_nested
             keys_values = arrays_values_to_nested_hash(hash)
             keys = keys_values.keys
@@ -67,11 +73,7 @@ module ReportsKit
           keys = keys.sort
           last_key = (dimension.last_key || keys.last).to_date
           last_key = last_key.beginning_of_week(ReportsKit.configuration.first_day_of_week) if granularity == 'week'
-
-          if granularity == 'week'
-            beginning_of_current_week = Date.today.beginning_of_week(ReportsKit.configuration.first_day_of_week)
-            last_key = [beginning_of_current_week, last_key].compact.max
-          end
+          last_key ||= Date.today.beginning_of_week(ReportsKit.configuration.first_day_of_week) if granularity == 'week'
 
           date = first_key
           populated_keys = []
@@ -145,8 +147,8 @@ module ReportsKit
           Value.new(raw_value, formatted_value)
         end
 
-        def self.normalize_filters(measure_properties, ui_filters)
-          measure_properties[:filters] = measure_properties[:filters].map do |filter_properties|
+        def self.normalize_filters(series_properties, ui_filters)
+          series_properties[:filters] = series_properties[:filters].map do |filter_properties|
             filter_properties = { key: filter_properties } if filter_properties.is_a?(String)
             key = filter_properties[:key]
             ui_key = filter_properties[:ui_key]
@@ -158,18 +160,20 @@ module ReportsKit
             end
             filter_properties
           end
-          measure_properties
+          series_properties
         end
 
         def self.normalize_properties(properties, ui_filters: nil)
+          can_have_nesting = properties[:composite_operator].present? || properties[:series].is_a?(Array)
           ui_filters ||= properties[:ui_filters]
           properties = properties.dup
-          properties[:measures] = [properties.delete(:measure)] if properties[:measure]
-          return properties if ui_filters.blank? || properties[:measures].blank?
-          properties[:measures] = properties[:measures].map do |measure_properties|
-            measure_properties = normalize_properties(measure_properties, ui_filters: ui_filters)
-            next(measure_properties) if measure_properties[:filters].blank?
-            normalize_filters(measure_properties, ui_filters)
+          properties[:series] ||= properties.slice(*Series::VALID_KEYS).presence
+          properties[:series] = [properties[:series]] if properties[:series].is_a?(Hash) && properties[:series].present?
+          return properties if ui_filters.blank? || properties[:series].blank?
+          properties[:series] = properties[:series].map do |series_properties|
+            series_properties = normalize_properties(series_properties, ui_filters: ui_filters) if can_have_nesting
+            next(series_properties) if series_properties[:filters].blank?
+            normalize_filters(series_properties, ui_filters)
           end
           properties
         end

data/lib/reports_kit/reports/dimension.rb

@@ -15,6 +15,10 @@ module ReportsKit
         properties[:key]
       end
 
+      def expression
+        properties[:expression] || key
+      end
+
       def label
         properties.key?(:label) ? properties[:label] : key.titleize
       end

data/lib/reports_kit/reports/{dimension_with_measure.rb → dimension_with_series.rb}

@@ -1,7 +1,6 @@
 module ReportsKit
   module Reports
-    class DimensionWithMeasure
-      DEFAULT_DIMENSION_INSTANCES_LIMIT = 30
+    class DimensionWithSeries
       DEFAULT_GRANULARITY = 'week'
       VALID_GRANULARITIES = %w(day week).freeze
       ADAPTER_NAMES_CLASSES = {
@@ -9,16 +8,16 @@ module ReportsKit
         'postgresql' => Adapters::Postgresql
       }.freeze
 
-      attr_accessor :dimension, :measure, :configuration
+      attr_accessor :dimension, :series, :configuration
 
-      delegate :key, :properties, :label, to: :dimension
+      delegate :key, :expression, :properties, :label, to: :dimension
       delegate :configured_by_association?, :configured_by_column?, :configured_by_model?, :configured_by_time?,
         :settings_from_model, :reflection, :instance_class, :model_class, :column_type,
         to: :configuration
 
-      def initialize(dimension:, measure:)
+      def initialize(dimension:, series:)
         self.dimension = dimension
-        self.measure = measure
+        self.series = series
         self.configuration = InferrableConfiguration.new(self, :dimensions)
         missing_group_setting = settings && !settings.key?(:group)
         raise ArgumentError.new("Dimension settings for dimension '#{key}' of #{model_class} must include :group") if missing_group_setting
@@ -84,7 +83,7 @@ module ReportsKit
         if configured_by_time?
           properties[:limit]
         else
-          properties[:limit] || DEFAULT_DIMENSION_INSTANCES_LIMIT
+          properties[:limit] || ReportsKit.configuration.default_dimension_limit
         end
       end
 
@@ -104,8 +103,8 @@ module ReportsKit
       end
 
       def datetime_filters
-        return [] unless measure.filters.present?
-        measure.filters.map(&:filter_type).select { |filter_type| filter_type.is_a?(FilterTypes::Datetime) }
+        return [] unless series.filters.present?
+        series.filters.map(&:filter_type).select { |filter_type| filter_type.is_a?(FilterTypes::Datetime) }
       end
 
       def should_be_sorted_by_count?

data/lib/reports_kit/reports/filter.rb

@@ -13,6 +13,10 @@ module ReportsKit
         properties[:key]
       end
 
+      def expression
+        properties[:expression] || key
+      end
+
       def label
         key.titleize
       end

data/lib/reports_kit/reports/filter_types/base.rb

@@ -2,11 +2,12 @@ module ReportsKit
   module Reports
     module FilterTypes
       class Base
-        attr_accessor :settings, :properties
+        attr_accessor :settings, :properties, :primary_dimension
 
-        def initialize(settings, properties)
+        def initialize(settings, properties, primary_dimension:)
           self.settings = settings || {}
           self.properties = properties
+          self.primary_dimension = primary_dimension
         end
 
         def apply_filter(records)
@@ -39,7 +40,7 @@ module ReportsKit
         end
 
         def column
-          settings[:column] || properties[:key]
+          settings[:column] || Data::Utils.quote_column_name(properties[:key])
         end
       end
     end

data/lib/reports_kit/reports/filter_types/boolean.rb

@@ -20,13 +20,13 @@ module ReportsKit
         end
 
         def boolean_value
-          case criteria[:value]
+          case value
           when true, 'true'
             true
           when false, 'false'
             false
           else
-            raise ArgumentError.new("Unsupported value: '#{criteria[:value]}'")
+            raise ArgumentError.new("Unsupported value: '#{value}'")
           end
         end
 
@@ -35,11 +35,11 @@ module ReportsKit
         end
 
         def valid?
-          criteria[:value].present?
+          value.present?
         end
 
         def conditions
-          settings[:conditions] || properties[:key]
+          settings[:conditions] || Data::Utils.quote_column_name(properties[:key])
         end
       end
     end

data/lib/reports_kit/reports/filter_types/datetime.rb

@@ -10,7 +10,7 @@ module ReportsKit
         def apply_conditions(records)
           case criteria[:operator]
           when 'between'
-            records.where("#{column} IS NOT NULL").where("#{column} BETWEEN ? AND ?", start_at, end_at)
+            records.where.not(column => nil).where(column => start_at..end_at)
           else
             raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
           end
@@ -21,8 +21,8 @@ module ReportsKit
             return unless valid?
             start_string, end_string = value.split(SEPARATOR)
             start_at = ReportsKit::Reports::Data::Utils.parse_date_string(start_string)
-            end_at = ReportsKit::Reports::Data::Utils.parse_date_string(end_string).end_of_day
-            [start_at, end_at]
+            end_at = ReportsKit::Reports::Data::Utils.parse_date_string(end_string)
+            adjust_range_to_dimension(start_at, end_at)
           end
         end
 
@@ -34,6 +34,16 @@ module ReportsKit
           start_at_end_at.try(:[], 1)
         end
 
+        def adjust_range_to_dimension(start_at, end_at)
+          return [start_at.beginning_of_day, end_at.end_of_day] unless primary_dimension.configured_by_time?
+          return [start_at.beginning_of_day, end_at.end_of_day] if primary_dimension.granularity == 'day'
+          return [
+            start_at.beginning_of_week(ReportsKit.configuration.first_day_of_week),
+            end_at.end_of_week(ReportsKit.configuration.first_day_of_week)
+          ] if primary_dimension.granularity == 'week'
+          [start_at, end_at]
+        end
+
         def valid?
           value.present?
         end

data/lib/reports_kit/reports/filter_types/number.rb

@@ -7,15 +7,15 @@ module ReportsKit
         def apply_conditions(records)
           case criteria[:operator]
           when '>'
-            records.where("#{column} > #{value.to_i}")
+            records.where(column => (value.to_i...Float::INFINITY))
           when '>='
-            records.where("#{column} >= #{value.to_i}")
+            records.where(column => (value.to_i..Float::INFINITY))
           when '<'
-            records.where("#{column} < #{value.to_i}")
+            records.where(column => (-Float::INFINITY...value.to_i))
           when '<='
-            records.where("#{column} <= #{value.to_i}")
+            records.where(column => (-Float::INFINITY..value.to_i))
           when '='
-            records.where("#{column} = #{value.to_i}")
+            records.where(column => value.to_i)
           else
             raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
           end