active_reporting 0.0.1 → 0.1.0

data/lib/active_reporting/metric.rb

@@ -0,0 +1,49 @@
+require 'forwardable'
+module ActiveReporting
+  AGGREGATES = %i(count sum max min avg).freeze
+
+  class Metric
+    extend Forwardable
+    def_delegators :@fact_model, :model
+    attr_reader :fact_model, :name, :dimensions, :dimension_filter, :aggregate, :metric_filter, :order_by_dimension
+
+    def initialize(
+      name,
+      fact_model:,
+      aggregate: :count,
+      dimensions: [],
+      dimension_filter: {},
+      metric_filter: {},
+      order_by_dimension: {}
+    )
+      @name               = name.to_sym
+      @fact_model         = fact_model
+      @dimension_filter   = dimension_filter
+      @aggregate          = determin_aggregate(aggregate.to_sym)
+      @metric_filter      = metric_filter
+      @dimensions         = ReportingDimension.build_from_dimensions(@fact_model, Array(dimensions))
+      @order_by_dimension = order_by_dimension
+      check_dimension_filter
+    end
+
+    # Builds an ActiveReporting::Report object based on the metric
+    #
+    # @return [ActiveReporting::Report]
+    def report
+      Report.new(self)
+    end
+
+    private ####################################################################
+
+    def check_dimension_filter
+      @dimension_filter.each do |name, _|
+        @fact_model.find_dimension_filter(name)
+      end
+    end
+
+    def determin_aggregate(agg)
+      raise UnknownAggregate, "Unknown aggregate '#{agg}'" unless AGGREGATES.include?(agg)
+      @aggregate = agg
+    end
+  end
+end

data/lib/active_reporting/report.rb

@@ -0,0 +1,149 @@
+require 'forwardable'
+module ActiveReporting
+  class Report
+    AGGREGATE_FUNCTION_OPERATORS = {
+      eq:   '=',
+      gt:   '>',
+      gte:  '>=',
+      lt:   '<',
+      lte:  '<='
+    }.freeze
+
+    extend Forwardable
+    def_delegators :@metric, :fact_model, :model
+
+    def initialize(metric, dimension_identifiers: true, dimension_filter: {}, dimensions: [], metric_filter: {})
+      @metric = metric.is_a?(Metric) ? metric : ActiveReporting.fetch_metric(metric)
+      raise UnknownMetric, "Unknown metric #{metric}" if @metric.nil?
+
+      @dimension_identifiers  = dimension_identifiers
+      local_dimensions        = ReportingDimension.build_from_dimensions(fact_model, Array(dimensions))
+      @dimensions             = (@metric.dimensions + local_dimensions).uniq
+      @metric_filter          = @metric.metric_filter.merge(metric_filter)
+      @ordering               = @metric.order_by_dimension
+      partition_dimension_filters dimension_filter
+    end
+
+    # Builds and executes a query, returning the raw result
+    #
+    # @return [Array]
+    def run
+      @run ||= build_data
+    end
+
+    private ######################################################################
+
+    def build_data
+      @data = model.connection.execute(statement.to_sql).to_a
+      apply_dimension_callbacks
+      @data
+    end
+
+    def partition_dimension_filters(user_dimension_filter)
+      @dimension_filters = { ransack: {}, scope: {}, lambda: {} }
+      user_dimension_filter.merge(@metric.dimension_filter).each do |key, value|
+        dm = fact_model.find_dimension_filter(key.to_sym)
+        @dimension_filters[dm.type][dm] = value
+      end
+    end
+
+    def statement
+      parts = {
+        select: select_statement,
+        joins: dimension_joins,
+        group: group_by_statement,
+        having: having_statement,
+        order: order_by_statement
+      }
+
+      statement = ([model] + parts.keys).inject do |chain, method|
+        chain.public_send(method, parts[method])
+      end
+
+      statement = process_scope_dimension_filter(statement)
+      statement = process_lambda_dimension_filter(statement)
+      statement = process_ransack_dimension_filter(statement)
+
+      statement
+    end
+
+    def select_statement
+      ss = ["#{select_aggregate} AS #{@metric.name}"]
+      ss += @dimensions.map { |d| d.select_statement(with_identifier: @dimension_identifiers) }
+      ss.flatten
+    end
+
+    def select_aggregate
+      case @metric.aggregate
+      when :count
+        'COUNT(*)'
+      else
+        "#{@metric.aggregate.to_s.upcase}(#{@metric.measure})"
+      end
+    end
+
+    def dimension_joins
+      @dimensions.select { |d| d.type == :standard }.map { |d| d.name.to_sym }
+    end
+
+    def group_by_statement
+      @dimensions.map { |d| d.group_by_statement(with_identifier: @dimension_identifiers) }
+    end
+
+    def process_scope_dimension_filter(chain)
+      @dimension_filters[:scope].each do |dm, args|
+        chain = if [true, 'true'].include?(args)
+                  chain.public_send(dm.name)
+                else
+                  chain.public_send(dm.name, args)
+                end
+      end
+      chain
+    end
+
+    def process_lambda_dimension_filter(chain)
+      @dimension_filters[:lambda].each do |df, args|
+        chain = if [true, 'true'].include?(args)
+                  chain.scoping { model.instance_exec(&df.body) }
+                else
+                  chain.scoping { model.instance_exec(args, &df.body) }
+                end
+      end
+      chain
+    end
+
+    def process_ransack_dimension_filter(chain)
+      ransack_hash = {}
+      @dimension_filters[:ransack].each do |dm, value|
+        ransack_hash[dm.name] = value
+      end
+      chain = chain.ransack(ransack_hash).result if ransack_hash.present?
+      chain
+    end
+
+    def having_statement
+      @metric_filter.map do |operator, value|
+        "#{select_aggregate} #{AGGREGATE_FUNCTION_OPERATORS[operator]} #{value.to_f}"
+      end.join(' AND ')
+    end
+
+    def order_by_statement
+      [].tap do |o|
+        @ordering.each do |dimension_key, direction|
+          dim = @dimensions.detect { |d| d.name.to_sym == dimension_key.to_sym }
+          o << dim.order_by_statement(direction: direction) if dim
+        end
+      end
+    end
+
+    def apply_dimension_callbacks
+      @dimensions.each do |dimension|
+        callback = dimension.label_callback
+        next unless callback
+        @data.each do |hash|
+          hash[dimension.name.to_s] = callback.call(hash[dimension.name.to_s])
+        end
+      end
+    end
+  end
+end

data/lib/active_reporting/reporting_dimension.rb

@@ -0,0 +1,102 @@
+require 'forwardable'
+module ActiveReporting
+  class ReportingDimension
+    extend Forwardable
+    def_delegators :@dimension, :name, :type, :klass, :association, :model, :hierarchical?
+
+    def self.build_from_dimensions(fact_model, dimensions)
+      Array(dimensions).map do |dim|
+        dimension_name, label = dim.is_a?(Hash) ? Array(dim).flatten : [dim, nil]
+        found_dimension = fact_model.dimensions[dimension_name.to_sym]
+        if found_dimension.nil?
+          raise UnknownDimension, "Dimension '#{dim}' not found on fact model '#{fact_model}'"
+        end
+        new(found_dimension, label: label)
+      end
+    end
+
+    def initialize(dimension, label: nil)
+      @dimension = dimension
+      determine_label(label)
+    end
+
+    # The foreign key to use in queries
+    #
+    # @return [String]
+    def foreign_key
+      association ? association.foreign_key : name
+    end
+
+    # Fragments of a select statement for queries that use the dimension
+    #
+    # @return [Array]
+    def select_statement(with_identifier: true)
+      return [degenerate_fragment] if type == :degenerate
+
+      ss = ["#{label_fragment} AS #{name}"]
+      ss << "#{identifier_fragment} AS #{name}_identifier" if with_identifier
+      ss
+    end
+
+    # Fragments of a group by clause for queries that use the dimension
+    #
+    # @return [Array]
+    def group_by_statement(with_identifier: true)
+      return [degenerate_fragment] if type == :degenerate
+
+      group = [label_fragment]
+      group << identifier_fragment if with_identifier
+      group
+    end
+
+    # Fragment of an order by clause for queries that sort by the dimension
+    #
+    # @return [String]
+    def order_by_statement(direction:)
+      direction = direction.to_s.upcase
+      raise "Ording direction should be 'asc' or 'desc'" unless %w(ASC DESC).include?(direction)
+      return "#{degenerate_fragment} #{direction}" if type == :degenerate
+      "#{label_fragment} #{direction}"
+    end
+
+    # Looks up the dimension label callback for the label
+    #
+    # @return [Lambda, NilClass]
+    def label_callback
+      klass.fact_model.dimension_label_callbacks[@label]
+    end
+
+    private ####################################################################
+
+    def determine_label(label)
+      @label = label.to_sym if label.present? && validate_hierarchical_label(label)
+      @label ||= dimension_fact_model.dimension_label || Configuration.default_dimension_label
+    end
+
+    def validate_hierarchical_label(hierarchical_label)
+      if !hierarchical?
+        raise InvalidDimensionLabel, "#{name} must be hierarchical to use label #{hierarchical_label}"
+      end
+      unless dimension_fact_model.hierarchical_levels.include?(hierarchical_label.to_sym)
+        raise InvalidDimensionLabel, "#{hierarchical_label} is not a hierarchical label in #{name}"
+      end
+      true
+    end
+
+    def degenerate_fragment
+      "#{model.quoted_table_name}.#{name}"
+    end
+
+    def identifier_fragment
+      "#{klass.quoted_table_name}.#{klass.primary_key}"
+    end
+
+    def label_fragment
+      "#{klass.quoted_table_name}.#{@label}"
+    end
+
+    def dimension_fact_model
+      @dimension_fact_model ||= klass.fact_model
+    end
+  end
+end

data/lib/active_reporting/version.rb

@@ -1,3 +1,3 @@
 module ActiveReporting
-  VERSION = "0.0.1"
+  VERSION = '0.1.0'.freeze
 end

metadata

@@ -1,29 +1,57 @@
 --- !ruby/object:Gem::Specification
 name: active_reporting
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Tony Drake
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-24 00:00:00.000000000 Z
+date: 2017-04-16 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.12'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -52,6 +80,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: ransack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - t27duck@gmail.com
@@ -59,8 +115,12 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
+- ".rubocop.yml"
 - ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -68,7 +128,17 @@ files:
 - active_reporting.gemspec
 - bin/console
 - bin/setup
+- gemfiles/4.0.gemfile
+- gemfiles/5.0.gemfile
 - lib/active_reporting.rb
+- lib/active_reporting/active_record_adaptor.rb
+- lib/active_reporting/configuration.rb
+- lib/active_reporting/dimension.rb
+- lib/active_reporting/dimension_filter.rb
+- lib/active_reporting/fact_model.rb
+- lib/active_reporting/metric.rb
+- lib/active_reporting/report.rb
+- lib/active_reporting/reporting_dimension.rb
 - lib/active_reporting/version.rb
 homepage: https://github.com/t27duck/active_reporting
 licenses:
@@ -90,8 +160,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
-summary: OLAP-like functionality that works with ActiveRecord
+summary: Add relational OLAP-like functionality for ActiveRecord
 test_files: []