reports_kit 0.1.0 → 0.2.0

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

@@ -27,7 +27,7 @@ module ReportsKit
         end
 
         def criteria
-          properties[:criteria]
+          @criteria ||= default_criteria.merge(properties[:criteria])
         end
 
         def value

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

@@ -3,7 +3,7 @@ module ReportsKit
     module FilterTypes
       class Boolean < Base
         DEFAULT_CRITERIA = {
-          operator: nil
+          value: nil
         }
 
         def apply_conditions(records)
@@ -11,29 +11,31 @@ module ReportsKit
           when ::String
             records.where("(#{conditions}) #{sql_operator} true")
           when ::Hash
-            boolean_operator ? records.where(conditions) : records.not.where(conditions)
+            boolean_value ? records.where(conditions) : records.not.where(conditions)
+          when ::Proc
+            conditions.call(records)
           else
             raise ArgumentError.new("Unsupported conditions type: '#{conditions}'")
           end
         end
 
-        def boolean_operator
-          case criteria[:operator]
+        def boolean_value
+          case criteria[:value]
           when true, 'true'
             true
           when false, 'false'
             false
           else
-            raise ArgumentError.new("Unsupported operator: '#{criteria[:operator]}'")
+            raise ArgumentError.new("Unsupported value: '#{criteria[:value]}'")
           end
         end
 
         def sql_operator
-          boolean_operator ? '=' : '!='
+          boolean_value ? '=' : '!='
         end
 
         def valid?
-          criteria[:operator].present?
+          criteria[:value].present?
         end
 
         def conditions

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

@@ -5,6 +5,7 @@ module ReportsKit
         DEFAULT_CRITERIA = {
           operator: 'between'
         }
+        SEPARATOR = ' - '
 
         def apply_conditions(records)
           case criteria[:operator]
@@ -17,19 +18,20 @@ module ReportsKit
 
         def start_at_end_at
           @start_at_end_at ||= begin
-            start_string, end_string = value.split(' - ')
-            start_at = Date.parse(start_string)
-            end_at = Date.parse(end_string)
+            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
         end
 
         def start_at
-          start_at_end_at[0]
+          start_at_end_at.try(:[], 0)
         end
 
         def end_at
-          start_at_end_at[1]
+          start_at_end_at.try(:[], 1)
         end
 
         def valid?

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

@@ -2,6 +2,8 @@ module ReportsKit
   module Reports
     module FilterTypes
       class Number < Base
+        DEFAULT_CRITERIA = {}
+
         def apply_conditions(records)
           case criteria[:operator]
           when '>'

data/lib/reports_kit/reports/filter_with_measure.rb

@@ -0,0 +1,84 @@
+module ReportsKit
+  module Reports
+    class FilterWithMeasure
+      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 :filter, :measure, :configuration
+
+      delegate :key, :properties, :label, to: :filter
+      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(filter:, measure:)
+        self.filter = filter
+        self.measure = measure
+        self.configuration = InferrableConfiguration.new(self, :filters)
+
+        self.properties[:criteria] = filter_type.default_criteria unless self.properties[:criteria]
+      end
+
+      def normalized_properties
+        return properties unless configured_by_time?
+        criteria = properties[:criteria]
+        return properties if criteria.blank? || criteria[:value].blank?
+        values = criteria[:value].split(ReportsKit::Reports::FilterTypes::Datetime::SEPARATOR)
+        values = values.map { |value| ReportsKit::Reports::Data::Utils.format_time_value(value) }
+        properties[:criteria][:value] = values.join(ReportsKit::Reports::FilterTypes::Datetime::SEPARATOR)
+        properties
+      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)
+      end
+    end
+  end
+end

data/lib/reports_kit/reports/generate_autocomplete_results.rb

@@ -42,7 +42,7 @@ module ReportsKit
       def model
         @model ||= begin
           measure = Measure.new(measure_key, context_record: context_record)
-          filter = Filter.new(filter_key, measure: measure)
+          filter = FilterWithMeasure.new(filter: Filter.new(filter_key), measure: measure)
           filter.instance_class
         end
       end

data/lib/reports_kit/reports/inferrable_configuration.rb

@@ -73,25 +73,44 @@ module ReportsKit
       def inferred_settings
         return { column: "#{model_class.table_name}.#{key}" } if configured_by_column?
         if configured_by_association?
-          return { column: "#{model_class.table_name}.#{reflection.foreign_key}" } if reflection.macro == :belongs_to
+          return inferred_settings_from_belongs_to_or_has_one if inferred_settings_from_belongs_to_or_has_one
           return inferred_settings_from_has_many if inferred_settings_from_has_many
         end
         {}
       end
 
+      def inferred_settings_from_belongs_to_or_has_one
+        @inferred_settings_from_belongs_to_or_has_one ||= begin
+          return unless reflection.macro.in?([:belongs_to, :has_one])
+          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
+      end
+
       def inferred_settings_from_has_many
-        return unless reflection.macro == :has_many
-        through_reflection = reflection.through_reflection
-        if through_reflection
-          {
-            joins: through_reflection.name,
-            column: "#{through_reflection.table_name}.#{reflection.source_reflection.foreign_key}"
-          }
-        else
-          {
-            joins: reflection.name,
-            column: "#{reflection.klass.table_name}.#{reflection.klass.primary_key}"
-          }
+        @inferred_settings_from_has_many ||= begin
+          return unless reflection.macro == :has_many
+          through_reflection = reflection.through_reflection
+          if through_reflection
+            {
+              joins: through_reflection.name,
+              column: "#{through_reflection.table_name}.#{reflection.source_reflection.foreign_key}"
+            }
+          else
+            {
+              joins: reflection.name,
+              column: "#{reflection.klass.table_name}.#{reflection.klass.primary_key}"
+            }
+          end
         end
       end
 

data/lib/reports_kit/reports/measure.rb

@@ -1,17 +1,22 @@
 module ReportsKit
   module Reports
-    class Measure
-      attr_accessor :properties, :filters, :context_record
+    class Measure < AbstractMeasure
+      attr_accessor :properties, :dimensions, :filters, :context_record
 
       def initialize(properties, context_record: nil)
+        properties = properties.dup
         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)
         properties = properties.deep_symbolize_keys
-        filter_hashes = properties.delete(:filters) || []
+
+        dimension_hashes = properties[:dimensions] || []
+        dimension_hashes = dimension_hashes.values if dimension_hashes.is_a?(Hash) && dimension_hashes.key?(:'0')
+        filter_hashes = properties[:filters] || []
         filter_hashes = filter_hashes.values if filter_hashes.is_a?(Hash) && filter_hashes.key?(:'0')
 
         self.properties = properties
-        self.filters = filter_hashes.map { |filter_hash| Filter.new(filter_hash, measure: self) }
+        self.dimensions = dimension_hashes.map { |dimension_hash| DimensionWithMeasure.new(dimension: Dimension.new(dimension_hash), measure: self) }
+        self.filters = filter_hashes.map { |filter_hash| FilterWithMeasure.new(filter: Filter.new(filter_hash), measure: self) }
         self.context_record = context_record
       end
 
@@ -20,7 +25,7 @@ module ReportsKit
       end
 
       def label
-        key.pluralize.titleize
+        properties[:name].presence || key.pluralize.titleize
       end
 
       def relation_name
@@ -28,11 +33,31 @@ module ReportsKit
       end
 
       def aggregate_function
-        :count
+        aggregation_expression || :count
+      end
+
+      def aggregation_expression
+        return unless aggregation_config
+        expression = aggregation_config[:expression]
+        if expression.is_a?(Array)
+          expression
+        else
+          raise ArgumentError.new("The '#{aggregation_key}' aggregation on the #{model_class} model isn't valid")
+        end
       end
 
-      def conditions
-        nil
+      def aggregation_key
+        properties[:aggregation]
+      end
+
+      def aggregation_config
+        @aggregation_config ||= begin
+          return unless aggregation_key
+          raise ArgumentError.new("A '#{aggregation_key}' aggregation on the #{model_class} model hasn't been configured") unless model_class.respond_to?(:reports_kit_configuration)
+          config = model_class.reports_kit_configuration.aggregations.find { |aggregation| aggregation[:key] == aggregation_key }
+          raise ArgumentError.new("A '#{aggregation_key}' aggregation on the #{model_class} model hasn't been configured") unless config
+          config
+        end
       end
 
       def base_relation
@@ -52,10 +77,21 @@ module ReportsKit
         relation
       end
 
-      def properties_with_filters
-        all_properties = properties
-        all_properties[:filters] = filters.map(&:properties)
-        all_properties
+      def has_two_dimensions?
+        dimensions.length == 2
+      end
+
+      def self.new_from_properties!(properties, context_record:)
+        measure_hashes = [properties[:measure]].compact + Array(properties[:measures])
+        raise ArgumentError.new('At least one measure must be configured') if measure_hashes.blank?
+
+        measure_hashes.map do |measure_hash|
+          if measure_hash[:composite_operator].present?
+            CompositeMeasure.new(measure_hash)
+          else
+            new(measure_hash, context_record: context_record)
+          end
+        end
       end
     end
   end

data/lib/reports_kit/reports_controller.rb

@@ -1,9 +1,48 @@
+require 'csv'
+require 'spreadsheet'
+
 module ReportsKit
   class ReportsController < ReportsKit::BaseController
     def index
-      properties = ActiveSupport::JSON.decode(params[:properties])
-      report_data = Reports::Data::Generate.new(properties, context_record: context_record).perform
-      render json: { data: report_data }
+      respond_to do |format|
+        format.json do
+          render json: { data: report_data }
+        end
+        format.csv do
+          properties[:format] = 'table'
+          csv = CSV.generate do |csv|
+            report_data[:table_data].each do |row|
+              csv << row
+            end
+          end
+          send_data csv, filename: "Report.csv"
+        end
+        format.xls do
+          properties[:format] = 'table'
+          send_data xls_string, filename: 'Report.xls', type:  'application/vnd.ms-excel'
+        end
+      end
+    end
+
+    private
+
+    def report_data
+      Reports::Data::Generate.new(properties, context_record: context_record).perform
+    end
+
+    def properties
+      @properties ||= ActiveSupport::JSON.decode(params[:properties])
+    end
+
+    def xls_string
+      spreadsheet = Spreadsheet::Workbook.new
+      sheet = spreadsheet.create_worksheet
+      report_data[:table_data].each_with_index do |row, index|
+        sheet.update_row(index, *row)
+      end
+      io = StringIO.new
+      spreadsheet.write(io)
+      io.string
     end
   end
 end

data/lib/reports_kit/version.rb

@@ -1,3 +1,3 @@
 module ReportsKit
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/reports_kit.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |s|
   s.license       = 'MIT'
 
   s.add_dependency 'rails', '>= 3'
+  s.add_dependency 'spreadsheet', '>= 1.1'
 
   s.add_development_dependency 'appraisal'
   s.add_development_dependency 'rspec', '~> 3'
@@ -21,5 +22,6 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'factory_girl', '~> 4'
   s.add_development_dependency 'pg', '>= 0.15'
   s.add_development_dependency 'pry', '~> 0'
+  s.add_development_dependency 'pry-byebug', '~> 1'
   s.add_development_dependency 'timecop', '~> 0'
 end

data/spec/fixtures/generate_inputs.yml

@@ -1,40 +1,165 @@
-- measure: issue
-  dimensions:
-  - repo
-- measure: issue
-  dimensions:
-  - repo
+- measure:
+    key: issue
+    dimensions:
+    - repo
+- measure:
+    key: issue
+    dimensions:
+    - repo
   chart:
     options:
       foo: bar
-- measure: issue
-  dimensions:
-  - repo
+- measure:
+    key: issue
+    dimensions:
+    - repo
   chart:
     foo: bar
-- measure: issue
-  dimensions:
-  - repo
+- measure:
+    key: issue
+    dimensions:
+    - repo
   chart:
     type: pie
 - measure:
     key: issue
-  dimensions:
-  - key: repo
+    dimensions:
+    - key: repo
 - measure:
     key: issue
-  dimensions:
-  - key: opened_at
+    dimensions:
+    - key: opened_at
 - measure:
     key: issue
-  dimensions:
-  - key: opened_at
-  - key: repo
+    dimensions:
+    - key: opened_at
+    - key: repo
 - measure:
     key: issue
     filters:
     - key: locked
     - key: title
     - key: opened_at
-  dimensions:
-  - key: repo
+    dimensions:
+    - key: repo
+- measures:
+  - key: issue
+    dimensions:
+    - repo
+  - key: label
+    dimensions:
+    - repo
+- measures:
+  - key: issue
+    dimensions:
+    - repo
+  - key: label
+    dimensions:
+    - repo
+  - key: tag
+    dimensions:
+    - repo
+- measures:
+  - key: issue
+    name: Repo Issues
+    dimensions:
+    - repo
+  - key: label
+    dimensions:
+    - repo
+- measures:
+  - key: issue
+    name: Repo Issues
+    dimensions:
+    - key: repo
+      label:
+  - key: label
+    dimensions:
+    - repo
+  format: table
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: dimension1.label
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: dimension1.label desc
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: count
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: count desc
+- measure:
+    key: issue
+    dimensions:
+    - opened_at
+  order: dimension1
+- measure:
+    key: issue
+    dimensions:
+    - opened_at
+  order: dimension1 desc
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: 0
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: 0 desc
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: 1
+- measure:
+    key: label
+    dimensions:
+    - repo
+  order: 1 desc
+- measure:
+    key: issue
+    dimensions:
+    - key: opened_at
+    - key: repo
+  order: dimension1
+- measure:
+    key: issue
+    dimensions:
+    - key: opened_at
+    - key: repo
+  order: dimension1 desc
+- measure:
+    key: label
+    dimensions:
+    - key: repo
+    - key: created_at
+  order: dimension1.label
+- measure:
+    key: label
+    dimensions:
+    - key: repo
+    - key: created_at
+  order: dimension1.label desc
+- measure:
+    key: issue
+    dimensions:
+    - key: opened_at
+    - key: repo
+  order: count
+- measure:
+    key: issue
+    dimensions:
+    - key: opened_at
+    - key: repo
+  order: count desc