reports_kit 0.1.0 → 0.2.0

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

@@ -2,16 +2,38 @@ module ReportsKit
   module Reports
     module Data
       class Utils
-        def self.format_time(time)
+        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_time_value(value)
+          time = RelativeTime.parse(value, prevent_exceptions: true)
+          return value unless time
+          Utils.format_configuration_time(time)
+        end
+
+        def self.format_number(number)
+          number_i = number.to_i
+          return number_i if number == number_i
+          number.round(Generate::ROUND_PRECISION)
+        end
+
+        def self.parse_date_string(string)
+          begin
+            Date.parse(string)
+          rescue ArgumentError
+            RelativeTime.parse(string)
+          end
+        end
+
         def self.populate_sparse_hash(hash, dimension:)
-          return hash if hash.blank?
           keys = hash.keys
-          is_nested = false
-          if keys.first.is_a?(Array)
-            is_nested = true
+          is_nested = dimension.measure.has_two_dimensions?
+          if is_nested
             keys_values = arrays_values_to_nested_hash(hash)
             keys = keys_values.keys
           else
@@ -36,22 +58,22 @@ module ReportsKit
         end
 
         def self.populate_sparse_keys(keys, dimension:)
-          return keys if keys.blank?
           first_key = dimension.first_key || keys.first
           return keys unless first_key.is_a?(Time) || first_key.is_a?(Date)
+          first_key = first_key.to_date
           granularity = dimension.granularity
 
-          first_key = first_key.beginning_of_week if granularity == 'week'
+          first_key = first_key.beginning_of_week(ReportsKit.configuration.first_day_of_week) if granularity == 'week'
           keys = keys.sort
-          last_key = dimension.last_key || keys.last
-          last_key = last_key.beginning_of_week if granularity == 'week'
+          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 = Time.now.utc.beginning_of_week(ReportsKit.configuration.first_day_of_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
 
-          date = first_key.to_date
+          date = first_key
           populated_keys = []
           interval = granularity == 'week' ? 1.week : 1.day
           loop do
@@ -94,11 +116,19 @@ module ReportsKit
           Hash[dimension_ids_dimension_instances]
         end
 
+        def self.dimension_key_to_entity(dimension_key, dimension, dimension_ids_dimension_instances)
+          instance = dimension_ids_dimension_instances ? dimension_ids_dimension_instances[dimension_key] : dimension_key
+          label = dimension_key_to_label(dimension_key, dimension, dimension_ids_dimension_instances)
+          Entity.new(dimension_key, label, instance)
+        end
+
         def self.dimension_key_to_label(dimension_instance, dimension, ids_dimension_instances)
+          label = dimension.key_to_label(dimension_instance)
+          return label if label
           return dimension_instance.to_s if dimension.configured_by_column? && dimension.column_type == :integer
           case dimension_instance
           when Time, Date
-            Utils.format_time(dimension_instance)
+            Utils.format_display_time(dimension_instance)
           when Fixnum
             raise ArgumentError.new("ids_dimension_instances must be present for Dimension with identifier: #{dimension_instance}") unless ids_dimension_instances
             instance = ids_dimension_instances[dimension_instance.to_i]
@@ -108,6 +138,41 @@ module ReportsKit
             dimension_instance.to_s.gsub(/\.0$/, '')
           end
         end
+
+        def self.raw_value_to_value(raw_value, value_format_method)
+          formatted_value = format_number(raw_value)
+          formatted_value = value_format_method.call(raw_value) if value_format_method
+          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|
+            filter_properties = { key: filter_properties } if filter_properties.is_a?(String)
+            key = filter_properties[:key]
+            ui_key = filter_properties[:ui_key]
+            value = ui_filters[key.to_sym]
+            value ||= ui_filters[ui_key.to_sym] if ui_key
+            if value
+              filter_properties[:criteria] ||= {}
+              filter_properties[:criteria][:value] = value
+            end
+            filter_properties
+          end
+          measure_properties
+        end
+
+        def self.normalize_properties(properties, ui_filters: nil)
+          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)
+          end
+          properties
+        end
       end
     end
   end

data/lib/reports_kit/reports/data/value.rb

@@ -0,0 +1,7 @@
+module ReportsKit
+  module Reports
+    module Data
+      Value = Struct.new(:raw, :formatted)
+    end
+  end
+end

data/lib/reports_kit/reports/dimension.rb

@@ -1,128 +1,22 @@
 module ReportsKit
   module Reports
     class Dimension
-      DEFAULT_DIMENSION_INSTANCES_LIMIT = 30
-      DEFAULT_GRANULARITY = 'week'
-      VALID_GRANULARITIES = %w(day week).freeze
-      ADAPTER_NAMES_CLASSES = {
-        'mysql2' => Adapters::Mysql,
-        'postgresql' => Adapters::Postgresql
-      }.freeze
-
-      attr_accessor :properties, :measure, :configuration
-
-      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(properties, measure:)
-        self.configuration = InferrableConfiguration.new(self, :dimensions)
-        self.measure = measure
+      attr_accessor :properties
 
+      def initialize(properties)
         raise ArgumentError.new('Blank properties') if properties.blank?
         properties = { key: properties } if properties.is_a?(String)
-        raise ArgumentError.new("Measure properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
+        raise ArgumentError.new("Dimension properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
         properties = properties.deep_symbolize_keys
         self.properties = properties
-        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
       end
 
       def key
         properties[:key]
       end
 
-      def granularity
-        @granularity ||= begin
-          return unless configured_by_time?
-          granularity = properties[:granularity] || DEFAULT_GRANULARITY
-          raise ArgumentError.new("Invalid granularity: #{granularity}") unless VALID_GRANULARITIES.include?(granularity)
-          granularity
-        end
-      end
-
       def label
-        key.titleize
-      end
-
-      def settings
-        inferred_settings.merge(settings_from_model)
-      end
-
-      def inferred_settings
-        configuration.inferred_settings.merge(inferred_dimension_settings)
-      end
-
-      def inferred_dimension_settings
-        {
-          group: group_expression
-        }
-      end
-
-      def group_expression
-        if configured_by_model?
-          settings_from_model[:group]
-        elsif configured_by_association?
-          "#{model_class.table_name}.#{reflection.foreign_key}"
-        elsif configured_by_column? && configured_by_time?
-          granularity == 'day' ? day_expression : week_expression
-        elsif configured_by_column?
-          column_expression
-        else
-          raise ArgumentError.new('Invalid group_expression')
-        end
-      end
-
-      def joins
-        settings_from_model[:joins] if configured_by_model?
-      end
-
-      def dimension_instances_limit
-        if configured_by_time?
-          properties[:limit]
-        else
-          properties[:limit] || DEFAULT_DIMENSION_INSTANCES_LIMIT
-        end
-      end
-
-      def first_key
-        return unless configured_by_time? && datetime_filters.present?
-        datetime_filters.map(&:start_at).compact.sort.first
-      end
-
-      def last_key
-        return unless configured_by_time? && datetime_filters.present?
-        datetime_filters.map(&:end_at).compact.sort.last
-      end
-
-      def datetime_filters
-        return [] unless measure.filters.present?
-        measure.filters.map(&:filter_type).select { |filter_type| filter_type.is_a?(FilterTypes::Datetime) }
-      end
-
-      def should_be_sorted_by_count?
-        !configured_by_time?
-      end
-
-      def adapter
-        @adapter ||= begin
-          adapter_name = model_class.connection_config[:adapter]
-          adapter = ADAPTER_NAMES_CLASSES[adapter_name]
-          raise ArgumentError.new("Unsupported adapter: #{adapter_name}") unless adapter
-          adapter
-        end
-      end
-
-      def column_expression
-        "#{model_class.table_name}.#{key}"
-      end
-
-      def day_expression
-        adapter.truncate_to_day(column_expression)
-      end
-
-      def week_expression
-        adapter.truncate_to_week(column_expression)
+        properties.key?(:label) ? properties[:label] : key.titleize
       end
     end
   end

data/lib/reports_kit/reports/dimension_with_measure.rb

@@ -0,0 +1,137 @@
+module ReportsKit
+  module Reports
+    class DimensionWithMeasure
+      DEFAULT_DIMENSION_INSTANCES_LIMIT = 30
+      DEFAULT_GRANULARITY = 'week'
+      VALID_GRANULARITIES = %w(day week).freeze
+      ADAPTER_NAMES_CLASSES = {
+        'mysql2' => Adapters::Mysql,
+        'postgresql' => Adapters::Postgresql
+      }.freeze
+
+      attr_accessor :dimension, :measure, :configuration
+
+      delegate :key, :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:)
+        self.dimension = dimension
+        self.measure = measure
+        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
+      end
+
+      def granularity
+        @granularity ||= begin
+          return unless configured_by_time?
+          granularity = properties[:granularity] || DEFAULT_GRANULARITY
+          raise ArgumentError.new("Invalid granularity: #{granularity}") unless VALID_GRANULARITIES.include?(granularity)
+          granularity
+        end
+      end
+
+      def settings
+        inferred_settings.merge(settings_from_model)
+      end
+
+      def inferred_settings
+        configuration.inferred_settings.merge(inferred_dimension_settings)
+      end
+
+      def inferred_dimension_settings
+        {
+          group: group_expression
+        }
+      end
+
+      def group_expression
+        if configured_by_model?
+          settings_from_model[:group]
+        elsif configured_by_association?
+          inferred_settings_from_association[:column]
+        elsif configured_by_column? && configured_by_time?
+          granularity == 'day' ? day_expression : week_expression
+        elsif configured_by_column?
+          column_expression
+        else
+          raise ArgumentError.new('Invalid group_expression')
+        end
+      end
+
+      def inferred_settings_from_association
+        through_reflection = reflection.through_reflection
+        if through_reflection
+          {
+            joins: through_reflection.name,
+            column: "#{through_reflection.table_name}.#{reflection.source_reflection.foreign_key}"
+          }
+        else
+          {
+            column: "#{model_class.table_name}.#{reflection.foreign_key}"
+          }
+        end
+      end
+
+      def joins
+        return settings_from_model[:joins] if configured_by_model?
+        inferred_settings_from_association[:joins] if configured_by_association?
+      end
+
+      def dimension_instances_limit
+        if configured_by_time?
+          properties[:limit]
+        else
+          properties[:limit] || DEFAULT_DIMENSION_INSTANCES_LIMIT
+        end
+      end
+
+      def first_key
+        return unless configured_by_time? && datetime_filters.present?
+        datetime_filters.map(&:start_at).compact.sort.first
+      end
+
+      def last_key
+        return unless configured_by_time? && datetime_filters.present?
+        datetime_filters.map(&:end_at).compact.sort.last
+      end
+
+      def key_to_label(key)
+        return unless settings[:key_to_label]
+        settings[:key_to_label].call(key)
+      end
+
+      def datetime_filters
+        return [] unless measure.filters.present?
+        measure.filters.map(&:filter_type).select { |filter_type| filter_type.is_a?(FilterTypes::Datetime) }
+      end
+
+      def should_be_sorted_by_count?
+        !configured_by_time?
+      end
+
+      def adapter
+        @adapter ||= begin
+          adapter_name = model_class.connection_config[:adapter]
+          adapter = ADAPTER_NAMES_CLASSES[adapter_name]
+          raise ArgumentError.new("Unsupported adapter: #{adapter_name}") unless adapter
+          adapter
+        end
+      end
+
+      def column_expression
+        "#{model_class.table_name}.#{key}"
+      end
+
+      def day_expression
+        adapter.truncate_to_day(column_expression)
+      end
+
+      def week_expression
+        adapter.truncate_to_week(column_expression)
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/filter.rb

@@ -1,35 +1,12 @@
 module ReportsKit
   module Reports
     class Filter
-      CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES = {
-        association: FilterTypes::Records,
-        boolean: FilterTypes::Boolean,
-        datetime: FilterTypes::Datetime,
-        integer: FilterTypes::Number,
-        string: FilterTypes::String
-      }
-      COLUMN_TYPES_FILTER_TYPE_CLASSES = {
-        boolean: FilterTypes::Boolean,
-        datetime: FilterTypes::Datetime,
-        integer: FilterTypes::Number,
-        string: FilterTypes::String
-      }
-
-      attr_accessor :properties, :measure, :configuration
-
-      delegate :configured_by_association?, :configured_by_column?, :configured_by_model?, :configured_by_time?,
-        :settings_from_model, :configuration_strategy, :instance_class, :column_type, :column,
-        to: :configuration
-
-      def initialize(properties, measure:)
-        self.configuration = InferrableConfiguration.new(self, :filters)
-        self.measure = measure
+      attr_accessor :properties
 
+      def initialize(properties)
         properties = { key: properties } if properties.is_a?(String)
-        raise ArgumentError.new("Measure properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
+        raise ArgumentError.new("Filter properties must be a String or Hash, not a #{properties.class.name}: #{properties.inspect}") unless properties.is_a?(Hash)
         self.properties = properties.deep_symbolize_keys
-        self.properties[:criteria] = filter_type.default_criteria unless self.properties[:criteria]
-        self.properties = self.properties
       end
 
       def key
@@ -40,44 +17,8 @@ module ReportsKit
         key.titleize
       end
 
-      def settings
-        inferred_settings.merge(settings_from_model)
-      end
-
-      def inferred_settings
-        configuration.inferred_settings.merge(inferred_filter_settings)
-      end
-
-      def inferred_filter_settings
-        {
-          column: column
-        }
-      end
-
-      def type_klass
-        type_klass_for_configuration_strategy = CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES[configuration_strategy]
-        return type_klass_for_configuration_strategy if type_klass_for_configuration_strategy
-        type_klass_for_column_type = COLUMN_TYPES_FILTER_TYPE_CLASSES[column_type]
-        return type_klass_for_column_type if type_klass_for_column_type
-        return filter_type_class_from_model if configured_by_model?
-        raise ArgumentError.new("No configuration found for filter with key: '#{key}'")
-      end
-
-      def filter_type
-        type_klass.new(settings, properties)
-      end
-
-      def filter_type_class_from_model
-        return unless settings
-        type_key = settings[:type_key]
-        raise ArgumentError.new("No type specified for filter with key: '#{key}'") unless type_key
-        type_class = CONFIGURATION_STRATEGIES_FILTER_TYPE_CLASSES[type_key]
-        raise ArgumentError.new("Invalid type ('#{type_key}') specified for filter with key: '#{key}'") unless type_class
-        type_class
-      end
-
-      def apply(relation)
-        filter_type.apply_filter(relation)
+      def normalized_properties
+        properties
       end
     end
   end