martyr 0.1.74.pre

data/lib/martyr/schema/metrics/metric_definition_collection.rb

@@ -0,0 +1,94 @@
+module Martyr
+  module Schema
+    class MetricDefinitionCollection < HashWithIndifferentAccess
+      include Martyr::Registrable
+      include Martyr::Translations
+
+      attr_reader :cube, :dependency_inferrer, :standardizer
+      delegate :cube_name, to: :cube
+
+      alias_method :find_metric, :find_or_error
+
+      def initialize(cube)
+        super()
+        @cube = cube
+        @dependency_inferrer = cube.metric_dependency_inferrer
+        @standardizer = Martyr::MetricIdStandardizer.new(cube_name)
+      end
+
+      def supports_metric?(metric_name)
+        has_key? second_element_from_id(metric_name, fallback: true)
+      end
+
+      # @see register_built_in_metric
+      def has_sum_metric(*args)
+        register_built_in_metric(:sum, *args)
+      end
+
+      # @see register_built_in_metric
+      def has_min_metric(*args)
+        register_built_in_metric(:min, *args)
+      end
+
+      # @see register_built_in_metric
+      def has_max_metric(*args)
+        register_built_in_metric(:max, *args)
+      end
+
+      # @param level [String] The level ID on which to perform the distinct count. The level must be connected to the
+      #   fact with has_dimension_level.
+      # @option null_unless [String] an SQL fragment that creates a helper field on which the COUNT DISTINCT occurs.
+      #   Example:
+      #     1. has_count_distinct_metric 'customer_count', level: 'customers.name'
+      #        Count distinct occurs on `customers.name`
+      #
+      #     2. has_count_distinct_metric 'customer_with_property_count', level: 'customers.name', null_unless: 'customers.property'
+      #        A helper field is created on which the COUNT DISTINCT occurs:
+      #       CASE WHEN customers.property THEN customers.id ELSE NULL END AS customer_with_property_count_helper
+      #
+      #       Since COUNT DISTINCT ignores null values, this can be an effective way to create boolean values
+      #
+      def has_count_distinct_metric(name, level:, null_unless: nil, fact_alias: name, typecast: :to_i,
+        sort: Sorter.identity, fact_grain: [], sub_query: [], sub_queries: [])
+
+        level_association = cube.dimension_associations.find_level_association(level)
+        register CountDistinctMetric.new cube_name: cube_name, name: name, fact_alias: fact_alias, typecast: typecast,
+            sort: sort, level: level_association, null_unless: null_unless, fact_grain: Array.wrap(fact_grain),
+            sub_queries: Array.wrap(sub_queries) + Array.wrap(sub_query)
+      end
+
+      def has_custom_metric(name, block, rollup: :sum, sort: Sorter.identity, depends_on: [], fact_grain: [])
+        inferrer = dependency_inferrer.infer_from_block(depends_on:
+            standardizer.standardize(depends_on), fact_grain: fact_grain, &block)
+
+        register CustomMetric.new cube_name: cube_name, name: name, block: block, rollup_function: rollup, sort: sort,
+            depends_on: inferrer.depends_on, fact_grain: inferrer.fact_grain
+      end
+
+      def has_custom_rollup(name, block, sort: Sorter.identity, depends_on: [], fact_grain: [])
+        inferrer = dependency_inferrer.infer_from_block(depends_on:
+            standardizer.standardize(depends_on), fact_grain: fact_grain, &block)
+
+        register CustomRollup.new cube_name: cube_name, name: name, block: block, sort: sort,
+          depends_on: inferrer.depends_on, fact_grain: inferrer.fact_grain
+      end
+
+      private
+
+      def register(metric)
+        super
+        dependency_inferrer.add_metric(metric)
+        metric
+      end
+
+      def register_built_in_metric(rollup_function, name, statement, fact_alias: name, typecast: :to_i,
+        sort: Sorter.identity, fact_grain: [], sub_query: [], sub_queries: [])
+
+        register BuiltInMetric.new cube_name: cube_name, name: name, statement: statement, fact_alias: fact_alias,
+          rollup_function: rollup_function, typecast: typecast, sort: sort, fact_grain: Array.wrap(fact_grain),
+          sub_queries: Array.wrap(sub_queries) + Array.wrap(sub_query)
+      end
+
+    end
+  end
+end

data/lib/martyr/schema/named_scopes/named_scope.rb

@@ -0,0 +1,19 @@
+module Martyr
+  module Schema
+    class NamedScope
+      include ActiveModel::Model
+
+      attr_reader :name, :proc
+
+      def initialize(name, proc)
+        @name = name.to_s
+        @proc = proc.to_proc
+      end
+
+      def run(query_context_builder, *args)
+        query_context_builder.instance_exec(*args, &@proc)
+      end
+
+    end
+  end
+end

data/lib/martyr/schema/named_scopes/named_scope_collection.rb

@@ -0,0 +1,42 @@
+module Martyr
+  module Schema
+    class NamedScopeCollection < HashWithIndifferentAccess
+      include Martyr::Registrable
+
+      # = DSL
+
+      def scope(name, proc)
+        named_scope = NamedScope.new(name, proc)
+        register(named_scope)
+        add_to_cube_helper_module(named_scope)
+        add_to_query_helper_module(named_scope)
+      end
+
+      def cube_helper_module
+        @cube_helper_module ||= Module.new
+      end
+
+      def query_helper_module
+        @query_helper_module ||= Module.new
+      end
+
+      private
+
+      # Delegates all named scopes to #new_query_context_builder
+      def add_to_cube_helper_module(named_scope)
+        cube_helper_module.module_eval do
+          delegate named_scope.name, to: :new_query_context_builder
+        end
+      end
+
+      def add_to_query_helper_module(named_scope)
+        query_helper_module.module_eval do
+          define_method(named_scope.name) do |*args|
+            named_scope.run(self, *args)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/schema/plain_dimension_levels/base_level_definition.rb

@@ -0,0 +1,39 @@
+module Martyr
+  module Schema
+    class BaseLevelDefinition
+      include ActiveModel::Model
+      include Martyr::Level
+
+      # @attribute fact_key [String] the field in the fact where the attribute resides. E.g.:
+      #   degenerate_level :country, fact_key: 'invoices.country'
+      #
+      # @attribute fact_alias [String] the alias to give in the `AS` part of the SQL fact statement.
+      #
+      # @attribute sort [Proc] optional lambda function for sorting.
+      #   For query levels it accepts the record:
+      #     ->(record) { record.custom_sort_order }
+      #
+      #   For degenerates it accepts the value:
+      #     ->(value) { value[1..2] }
+      #
+      attr_accessor :name, :fact_key, :fact_alias, :sort
+
+      delegate :dimension_name, :dimension_definition, to: :collection
+      alias_method :slice_id, :dimension_name
+      delegate :build_data_slice, :build_memory_slice, to: :dimension_definition
+
+      # This allows to ask any Martyr::Level for #level_definition
+      def level_definition
+        self
+      end
+
+      def dimension_definition
+        collection.dimension
+      end
+
+      def supported?
+        false
+      end
+    end
+  end
+end

data/lib/martyr/schema/plain_dimension_levels/degenerate_level_definition.rb

@@ -0,0 +1,75 @@
+module Martyr
+  module Schema
+    class DegenerateLevelDefinition < BaseLevelDefinition
+
+      # @attribute query_level_key [String] the field in the query level where the degenerate attribute resides. E.g.:
+      #   degenerate_level :country, query_level_key: 'billing_country'
+      #
+      # @attribute query_level_with_finder [Proc] the block to run on the query level's ActiveRecord scope. The block
+      #   receives two arguments - `scope` and `values`. E.g.:
+      #   ->(scope, values) { scope.where('billing_country' => values) }
+      #
+      attr_accessor :query_level_key, :query_level_with_finder, :value_method
+      attr_reader :loaded
+
+      # @param collection [DimensionDefinitionCollection]
+      # @param name [String, Symbol]
+      def initialize(collection, name, **options)
+        @collection = collection
+        hash = {name: name.to_s,
+                query_level_key: options[:query_level_key] || name,
+                value_method: options[:value_method] || "#{dimension_name}_#{name}",
+                fact_key: options[:fact_key] || "#{dimension_name}_#{name}",
+                fact_alias: options[:fact_alias] || "#{dimension_name}_#{name}",
+                sort: options[:sort] || Sorter.identity }
+
+        hash.merge! label_expression: options[:label_expression] if options[:label_expression]
+
+        super hash
+
+        @query_level_with_finder = options[:query_level_with_finder] || default_query_level_with_finder
+        @loaded = false
+      end
+
+      def label_key
+        nil
+      end
+
+      def label_expression
+        nil
+      end
+
+      def query?
+        false
+      end
+
+      def degenerate?
+        true
+      end
+
+      def build(collection)
+        Runtime::DegenerateLevelScope.new(collection, self)
+      end
+
+      # @param mod [Module]
+      def register_element_helper_methods(mod)
+        level_id = id
+        level_definition = self
+        mod.module_eval do
+          define_method(level_definition.value_method) { fetch(level_id) }
+        end
+      end
+
+      def helper_methods
+        [value_method]
+      end
+
+      private
+
+      def default_query_level_with_finder
+        ->(scope, values){ scope.where query_level_key => values }
+      end
+
+    end
+  end
+end

data/lib/martyr/schema/plain_dimension_levels/level_definition_collection.rb

@@ -0,0 +1,15 @@
+module Martyr
+  module Schema
+    class LevelDefinitionCollection < HashWithIndifferentAccess
+      include Martyr::LevelCollection
+
+      def degenerate_level(*args)
+        register DegenerateLevelDefinition.new(self, *args)
+      end
+
+      def query_level(*args)
+        register QueryLevelDefinition.new(self, *args)
+      end
+    end
+  end
+end

data/lib/martyr/schema/plain_dimension_levels/query_level_definition.rb

@@ -0,0 +1,99 @@
+module Martyr
+  module Schema
+    class QueryLevelDefinition < BaseLevelDefinition
+
+      LABEL_EXPRESSION_ALIAS = 'martyr_label_expression'
+
+      attr_accessor :scope, :primary_key, :label_key, :label_expression, :id_method, :record_method, :value_method,
+        :parent_association_name
+
+      # @param collection [DimensionDefinitionCollection]
+      # @param name [String, Symbol]
+      # @param scope [Proc]
+      # @option primary_key [String]
+      # @option label_key [String]
+      # @option fact_key [String]
+      # @option fact_alias [String]
+      def initialize(collection, name, scope = nil, **options)
+        @collection = collection
+        @scope = scope || default_scope
+        super name: name.to_s,
+              primary_key: options[:primary_key] || 'id',
+              label_key: options[:label_key] || name.to_s,
+              label_expression: options[:label_expression],
+              id_method: options[:id_method] || "#{dimension_name}_#{name}_id",
+              record_method: options[:record_method] || "#{dimension_name}_#{name}_record",
+              value_method: options[:value_method] || "#{dimension_name}_#{name}",
+              fact_key: options[:fact_key] || "#{dimension_name}_#{name}_id",
+              fact_alias: options[:fact_alias] || "#{dimension_name}_#{name}_id",
+              parent_association_name: options[:parent_association_name]
+
+        self.sort = options[:sort] || Sorter.default_for_query(label_field)
+        add_label_expression_to_scope
+      end
+
+      def query?
+        true
+      end
+
+      def degenerate?
+        false
+      end
+
+      def parent_association_name_with_default
+        (parent_association_name || level_above.try(:name)).to_s.presence
+      end
+
+      def label_field
+        label_expression ? LABEL_EXPRESSION_ALIAS : label_key
+      end
+
+      def build(collection)
+        Runtime::QueryLevelScope.new(collection, self)
+      end
+
+      # @param record [ActiveRecord::Base]
+      def record_value(record)
+        record.try(label_field)
+      end
+
+      # @param mod [Module]
+      def register_element_helper_methods(mod)
+        level_id = id
+        level_definition = self
+        mod.module_eval do
+          define_method(level_definition.id_method) { key_for(level_id) }
+          define_method(level_definition.record_method) { record_for(level_id) }
+          define_method(level_definition.value_method) { fetch(level_id) }
+        end
+      end
+
+      def helper_methods
+        [id_method, record_method, value_method]
+      end
+
+      private
+
+      # @return [Proc] a lambda object representing running #all on the guessed-class
+      def default_scope
+        begin
+          klass = dimension_name.classify.constantize
+          ->{ klass.all }
+        rescue => e
+          raise Schema::Error.new(e)
+        end
+      end
+
+      def add_label_expression_to_scope
+        return unless label_expression
+        original_scope = @scope.call
+        if original_scope.select_values.present?
+          @scope = -> { original_scope.select("#{label_expression} AS #{LABEL_EXPRESSION_ALIAS}") }
+        else
+          @scope = -> { original_scope.select("#{original_scope.klass.table_name}.*", "#{label_expression} AS #{LABEL_EXPRESSION_ALIAS}") }
+        end
+      end
+
+    end
+  end
+end

data/lib/martyr/version.rb

@@ -0,0 +1,3 @@
+module Martyr
+  VERSION = "0.1.74.pre"
+end

data/lib/martyr/virtual_cube.rb

@@ -0,0 +1,74 @@
+module Martyr
+  class VirtualCube < BaseCube
+
+    def self.contained_cube_classes
+      @contained_cube_classes ||= []
+    end
+
+    def self.metric_definitions
+      @metric_definitions ||= Schema::MetricDefinitionCollection.new(self)
+    end
+
+    # = DSL
+
+    def self.use_cube(class_name)
+      contained_cube_classes << class_name.constantize
+    end
+
+    def self.dimension_definitions
+      merge_from_cubes(Schema::DimensionDefinitionCollection.new, &:dimension_definitions)
+    end
+
+    def self.supported_dimension_definitions
+      merge_from_cubes(Schema::DimensionDefinitionCollection.new, &:supported_dimension_definitions)
+    end
+
+    class << self
+      delegate :find_metric, :has_custom_rollup, to: :metric_definitions
+      delegate :select, :slice, :granulate, :pivot, to: :new_query_context_builder
+      alias_method :all, :new_query_context_builder
+      alias_method :metrics, :metric_definitions
+    end
+
+    # @param mergeable [#merge!]
+    def self.merge_from_cubes(mergeable)
+      contained_cube_classes.inject(mergeable) do |merged_object, contained_cube|
+        merged_object.merge! yield(contained_cube)
+      end
+    end
+
+    def self.virtual?
+      true
+    end
+
+    # @override
+    def self.find_metric_id(metric_id)
+      cube_name, metric_name = id_components(metric_id)
+      if cube_name == self.cube_name
+        find_metric(metric_name)
+      else
+        find_cube(cube_name).find_metric(metric_name)
+      end
+    end
+
+    def self.find_cube(cube_name)
+      contained_cube_classes.find{ |cube| cube.cube_name == cube_name } ||
+        raise(Schema::Error.new "Could not find `#{cube_name}`")
+    end
+
+    # @return [Schema::DependencyInferrer]
+    def self.metric_dependency_inferrer
+      return @metric_dependency_inferrer if @metric_dependency_inferrer
+      inferrer = Schema::DependencyInferrer.new
+      contained_cube_classes.each do |contained_cube|
+        inferrer.add_cube_levels(contained_cube)
+      end
+      @metric_dependency_inferrer = inferrer
+    end
+
+    def self.standardizer
+      @standardizer ||= Martyr::MetricIdStandardizer.new(cube_name, raise_if_not_ok: true)
+    end
+
+  end
+end

data/lib/martyr.rb

@@ -0,0 +1,55 @@
+require 'martyr/version'
+
+require 'csv'
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_model'
+require 'active_record'
+
+require 'martyr/helpers/translations'
+require 'martyr/runtime/slices/has_scoped_levels'
+require 'martyr/runtime/data_set/element_common'
+
+Dir.glob(File.expand_path '../martyr/helpers/*.rb', __FILE__).each{|x| require File.expand_path(x).split('.rb').first}
+Dir.glob(File.expand_path '../martyr/level_concern/*.rb', __FILE__).each{|x| require File.expand_path(x).split('.rb').first}
+Dir.glob(File.expand_path '../martyr/runtime/scope_operators/*.rb', __FILE__).each{|x| require File.expand_path(x).split('.rb').first}
+Dir.glob(File.expand_path '../martyr/**/*.rb', __FILE__).each{|x| require File.expand_path(x).split('.rb').first}
+
+# require 'martyr/base'
+# require 'martyr/errors'
+#
+# require 'martyr/schema/helpers/registrable'
+# require 'martyr/schema/helpers/has_scope'
+#
+# require 'martyr/schema/dimensions/dimension_definition'
+# require 'martyr/schema/dimensions/degenerate_dimension'
+# require 'martyr/schema/dimensions/query_dimension'
+# require 'martyr/schema/dimensions/time_dimension'
+# require 'martyr/schema/dimensions/dimension_definition_collection'
+# require 'martyr/schema/dimensions/shared_dimension_wrapper'
+# require 'martyr/schema/dimensions/level_collection'
+# require 'martyr/schema/dimensions/level'
+#
+# require 'martyr/schema/facts/fact_definition_collection'
+# require 'martyr/schema/facts/main_fact_scope'
+# require 'martyr/schema/facts/sub_fact_scope'
+#
+# require 'martyr/schema/metrics/built_in_metric'
+# require 'martyr/schema/metrics/custom_metric'
+# require 'martyr/schema/metrics/metric_definition_collection'
+#
+# require 'martyr/schema/rollups/custom_rollup'
+# require 'martyr/schema/rollups/rollup_definition_collection'
+#
+# require 'martyr/runtime/query/query_context'
+#
+# require 'martyr/runtime/slices/base_dimension_slice'
+# require 'martyr/runtime/slices/compound_slice'
+# require 'martyr/runtime/slices/degenerate_dimension_slice'
+# require 'martyr/runtime/slices/metric_slice'
+# require 'martyr/runtime/slices/query_dimension_slice'
+# require 'martyr/runtime/slices/time_dimension_slice'
+
+module Martyr
+  # Your code goes here...
+end

data/martyr.gemspec

@@ -0,0 +1,41 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'martyr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "martyr"
+  spec.version       = Martyr::VERSION
+  spec.authors       = ["Amit Aharoni"]
+  spec.email         = ["amit.sites@gmail.com"]
+
+  spec.summary       = %q{Add data mart and pivoting functionality to Active Record models}
+  spec.description   = %q{A multi-dimensional semantic layer on top of ActiveRecord that allows running pivot table queries and rendering them as CSV, HTML, or KickChart-ready hashes. Supports time dimensions, cohort analysis, custom rollups, and drilling through to the underlying ActiveRecord objects.}
+  spec.homepage      = "https://github.com/vaharoni/martyr"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "sqlite3", "~> 1.3"
+  spec.add_development_dependency "activerecord", "~> 4.2"
+  spec.add_development_dependency "chinook_database", "~> 0.1"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "pry-byebug", "~> 3.3"
+
+  spec.add_runtime_dependency "activesupport", "~> 4.2"
+  spec.add_runtime_dependency "activemodel", "~> 4.2"
+end