martyr 0.1.74.pre

data/lib/martyr/helpers/delegators.rb

@@ -0,0 +1,17 @@
+module Martyr
+  module Delegators
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def each_child_delegator(*method_names, to:)
+        method_names.each do |method_name|
+          define_method(method_name) do |*args|
+            send(to).each do |obj|
+              obj.send(method_name, *args)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/martyr/helpers/intervals.rb

@@ -0,0 +1,222 @@
+# Mini and naive library for handling interval overlaps.
+# Used predominantly for compounding metric slices.
+module Martyr
+  class IntervalSet
+    attr_reader :set
+
+    def initialize(**options)
+      @set = []
+      add(**options) if options.present?
+    end
+
+    def null?
+      set.empty?
+    end
+
+    def continuous?
+      set.length == 1
+    end
+
+    def add(from: -Float::INFINITY, to: Float::INFINITY)
+      new_interval = Interval.new(from, to)
+      new_interval_set = []
+      @set.each do |old_interval|
+        if old_interval.touch?(new_interval)
+          new_interval = new_interval.union(old_interval)
+        else
+          new_interval_set << old_interval
+        end
+      end
+      set_interval_set new_interval_set + [new_interval]
+    end
+
+    # @param other [IntervalSet]
+    def intersect(other)
+      new_interval_set = []
+      other.set.each do |other_interval|
+        new_interval_set += set.select{|x| x.overlap?(other_interval)}.map{|x| x.intersect(other_interval)}
+      end
+      set_interval_set new_interval_set
+    end
+
+    def set_interval_set(set)
+      @set = set.sort_by{|interval| interval.from.x.to_f}
+      self
+    end
+
+    # @return [Array<Numeric>] array of holes - these are open edges that touch each other
+    # @note self will be amended to have the holes filled
+    def extract_and_fill_holes
+      holes = []
+      last_edge = nil
+      set.each do |interval|
+        holes << last_edge if interval.from.open? and interval.from.x == last_edge
+        last_edge = interval.to.x if interval.to.open?
+      end
+
+      # Fill in the holes
+      holes.each do |hole|
+        add from: [hole], to: [hole]
+      end
+
+      holes
+    end
+
+    # @return [Array<>]
+    def extract_and_remove_points
+      points = @set.select(&:point?).map{|interval| interval.from.x}
+      @set.reject!(&:point?)
+      points
+    end
+
+    # @return [nil, PointInterval]
+    def upper_bound
+      return nil if null?
+      upper_point = set.last.to
+      upper_point.infinity? ? nil : upper_point
+    end
+
+    # @return [PointInterval]
+    def lower_bound
+      return nil if null?
+      upper_point = set.first.from
+      upper_point.infinity? ? nil : upper_point
+    end
+  end
+
+  # The convention for a basic interval is as follows:
+  #   Array value - means including that point
+  #   Integer value - means not including that point
+  #
+  #   Example:
+  #     Interval.new [5], 6 - legal
+  #     Interval.new [5], [5] - legal
+  #     Interval.new [5], 5 - illegal
+  class Interval
+    attr_reader :from, :to
+
+    def initialize(from, to)
+      @from = PointInterval.new(Array.wrap(from).first, from.is_a?(Array), :right)
+      @to = PointInterval.new(Array.wrap(to).first, to.is_a?(Array), :left)
+      raise Martyr::Error.new('from cannot be bigger than to') if @from.outside?(@to) or @from.equal_but_empty?(@to)
+    end
+
+    def point?
+      from.closed? and to.closed? and from.x == to.x
+    end
+
+    def overlap?(other)
+      doesnt_overlap = (to.outside?(other.from) or to.equal_but_empty?(other.from) or from.outside?(other.to) or from.equal_but_empty?(other.to))
+      !doesnt_overlap
+    end
+
+    def touch?(other)
+      return true if overlap?(other)
+      return true if to.equal_and_mergeable?(other.from) or from.equal_and_mergeable?(other.to)
+      false
+    end
+
+    def intersect(other)
+      return nil unless overlap?(other)
+      self.class.new from.max_with(other.from).to_param, to.min_with(other.to).to_param
+    end
+
+    def union(other)
+      return nil unless touch?(other)
+      self.class.new from.min_with(other.from).to_param, to.max_with(other.to).to_param
+    end
+  end
+
+  # This represents a starting point and a direction (:left or :right), together with whether the interval includes
+  # or excludes the point.
+  class PointInterval
+    attr_reader :x, :direction
+
+    def initialize(x, closed, direction)
+      @x = x
+      @closed = closed
+      @direction = direction.to_sym
+      raise 'direction must be either left or right' unless [:left, :right].include?(@direction)
+    end
+
+    def to_param
+      closed? ? Array.wrap(x) : x
+    end
+
+    def infinity?
+      x == Float::INFINITY or x == -Float::INFINITY
+    end
+
+    def open?
+      !@closed
+    end
+
+    def closed?
+      !!@closed
+    end
+
+    def right?
+      direction == :right
+    end
+
+    def left?
+      direction == :left
+    end
+
+    def equal_and_mergeable?(other)
+      return false if x != other.x
+      return false if open? and other.open?
+      true
+    end
+
+    def equal_but_empty?(other)
+      return false if x != other.x
+      return false if closed? and other.closed?
+      true
+    end
+
+    def inside?(other)
+      raise 'other is pointing to the same direction' if direction == other.direction
+      if other.right? and other.closed?
+        x >= other.x
+      elsif other.right? and other.open?
+        x > other.x
+      elsif other.left? and other.closed?
+        x <= other.x
+      elsif other.left? and other.open?
+        x < other.x
+      end
+    end
+
+    def outside?(other)
+      raise 'other is pointing to the same direction' if direction == other.direction
+      if other.right? and other.closed?
+        x.to_f < other.x.to_f
+      elsif other.right? and other.open?
+        x.to_f <= other.x.to_f
+      elsif other.left? and other.closed?
+        x.to_f > other.x.to_f
+      elsif other.left? and other.open?
+        x.to_f >= other.x.to_f
+      end
+    end
+
+    def max_with(other)
+      raise 'other is pointing to a different direction' unless direction == other.direction
+      if x == other.x
+        return [self, other].select(&:closed?).first || self if left?
+        return [self, other].select(&:open?).first || self if right?
+      end
+      [self, other].sort_by{|p| p.x.to_f}.last
+    end
+
+    def min_with(other)
+      raise 'other is pointing to a different direction' unless direction == other.direction
+      if x == other.x
+        return [self, other].select(&:open?).first || self if left?
+        return [self, other].select(&:closed?).first || self if right?
+      end
+      [self, other].sort_by{|p| p.x.to_f}.first
+    end
+  end
+end

data/lib/martyr/helpers/metric_id_standardizer.rb

@@ -0,0 +1,47 @@
+module Martyr
+  class MetricIdStandardizer
+    include Martyr::Translations
+
+    def initialize(cube_name = nil, raise_if_not_ok: false)
+      @cube_name = cube_name
+      @raise_if_not_ok = raise_if_not_ok
+    end
+
+    def standardize(object)
+      if object.is_a?(String) or object.is_a?(Symbol)
+        standardize_id(object)
+      elsif object.is_a?(Array)
+        standardize_arr(object)
+      elsif object.is_a?(Hash)
+        standardize_hash(object)
+      else
+        raise Internal::Error.new("Does not know how to standardize #{object.inspect}")
+      end
+    end
+
+    def standardize_id(id)
+      with_standard_id(id) do |dimension_or_cube_or_metric, level_or_metric|
+        level_or_metric ? id : add_cube_name_to(dimension_or_cube_or_metric)
+      end
+    end
+
+    def standardize_arr(arr)
+      arr.map{|id| standardize_id(id)}
+    end
+
+    def standardize_hash(hash)
+      arr = hash.map do |key, value|
+        [standardize_id(key), value]
+      end
+      Hash[arr]
+    end
+
+    private
+
+    def add_cube_name_to(id)
+      raise Query::Error.new("Invalid metric #{id}: must be preceded with cube name") if @raise_if_not_ok
+      @cube_name.nil? ? id : "#{@cube_name}.#{id}"
+    end
+
+  end
+end

data/lib/martyr/helpers/registrable.rb

@@ -0,0 +1,15 @@
+module Martyr
+  module Registrable
+    def register(object)
+      self.[]=(object.name.to_s, object)
+    end
+
+    def find_or_nil(name)
+      self.[](name.to_s)
+    end
+
+    def find_or_error(name)
+      find_or_nil(name) || raise(Schema::Error.new "#{self.class.name}: Could not find `#{name}`")
+    end
+  end
+end

data/lib/martyr/helpers/sorter.rb

@@ -0,0 +1,79 @@
+module Martyr
+  class Sorter
+
+    def self.default_for_query(label_field)
+      ->(record) { record.try(label_field) }
+    end
+
+    def self.identity
+      ->(value) { value }
+    end
+
+    def self.args_to_hash(arg)
+      arg.is_a?(Hash) ? arg : Hash[Array.wrap(arg).map{|x| [x, :asc]}]
+    end
+
+    def initialize(args)
+      @order_hash = self.class.args_to_hash(args)
+      @definition_arr = []
+      @order_hash.keys.each do |key|
+        @definition_arr << yield(key)
+      end
+    end
+
+    def sort(elements)
+      return elements unless @definition_arr.present?
+      uniq_values = extract_uniq_values(elements)
+      lookups = build_sort_order_lookup(uniq_values)
+
+      elements.sort_by do |element|
+        @definition_arr.each_with_index.map{|definition, i| lookups[i][extract_value_from_definition(element, definition)] }
+      end
+    end
+
+    private
+
+    def extract_value_from_definition(element, definition)
+      definition.is_a?(Schema::QueryLevelDefinition) ? element.record_for(definition.id) : element.fetch(definition.id)
+    end
+
+    def direction_at(index)
+      @order_hash.values[index]
+    end
+
+    def sorter_proc_at(index)
+      direction = direction_at(index)
+      return direction if direction.respond_to?(:call)
+      @definition_arr[index].sort
+    end
+
+    # @param elements [Array<Element>] elements to be sorted
+    # @return [Array<Array>] each index of the master array corresponds to one level of nested sorting.
+    #   E.g., if the user asked to sort by ['genres.name', 'media_types.name'], the result will be an array where
+    #     index 0 contains all unique values of the genres extracted from the elements, and index 0 contains all
+    #     unique values of the media types extracted from the elements.
+    #
+    def extract_uniq_values(elements)
+      arr = []
+      @definition_arr.each_with_index do |definition, i|
+        elements.each do |element|
+          value = extract_value_from_definition(element, definition)
+          arr[i] ||= {}
+          arr[i][value] = true
+        end
+      end
+      arr.map!(&:keys)
+    end
+
+    # @param uniq_values [Array<Hash>] see return value of #extract_uniq_values
+    def build_sort_order_lookup(uniq_values)
+      lookups = []
+      uniq_values.each_with_index do |uniq_values_arr, i|
+        sorted_values = uniq_values_arr.sort_by { |x| sorter_proc_at(i).call(x) }
+        sorted_values.reverse! if direction_at(i).to_s == 'desc'
+        lookups << Hash[sorted_values.each_with_index.map{|value, i| [value, i]}]
+      end
+      lookups
+    end
+  end
+end

data/lib/martyr/helpers/translations.rb

@@ -0,0 +1,34 @@
+module Martyr
+  module Translations
+
+    def with_standard_id(id)
+      x, y = id_components(id)
+      y.nil? ? yield(id.to_s) : yield(x, y)
+    end
+
+    def id_components(id)
+      id_s = id.to_s
+      id_s.split('.')
+    end
+
+    def first_element_from_id(id)
+      id.to_s.include?('.') ? id.to_s.split('.').first : id.to_s
+    end
+
+    # @param id [String]
+    # @option fallback [Boolean] if true, will return the id if only one element exists in the id
+    def second_element_from_id(id, fallback: false)
+      if id.to_s.include?('.')
+        id.to_s.split('.').last
+      else
+        fallback ? id.to_s : nil
+      end
+    end
+
+    def to_id(object)
+      return object if object.is_a?(String)
+      object.id
+    end
+
+  end
+end

data/lib/martyr/level_concern/has_level_collection.rb

@@ -0,0 +1,11 @@
+module Martyr
+  module HasLevelCollection
+    extend ActiveSupport::Concern
+
+    included do
+      attr_reader :levels
+      delegate :lowest_level, :level_above, :find_level, :level_names, :level_objects, :has_level?, to: :levels
+    end
+
+  end
+end

data/lib/martyr/level_concern/level.rb

@@ -0,0 +1,45 @@
+module Martyr
+  module Level
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :collection
+    end
+
+    def id
+      "#{dimension_name}.#{name}"
+    end
+
+    # Used for reflection
+    def level_object?
+      true
+    end
+
+    def level_above
+      @_level_above ||= collection.level_above(name)
+    end
+
+    def level_below
+      @_level_below ||= collection.level_below(name)
+    end
+
+    def level_index
+      @_level_index ||= collection.level_index(name)
+    end
+    alias_method :to_i, :level_index
+
+    def query_level_below
+      @_query_level_below ||= collection.query_level_below(name)
+    end
+
+    def level_and_above
+      @_level_and_above ||= collection.level_and_above(name)
+    end
+
+    def level_and_below
+      @_level_and_below ||= collection.level_and_below(name)
+    end
+
+  end
+end
+

data/lib/martyr/level_concern/level_collection.rb

@@ -0,0 +1,60 @@
+module Martyr
+  module LevelCollection
+    extend ActiveSupport::Concern
+
+    include ActiveModel::Model
+    include Martyr::Registrable
+
+    included do
+      attr_accessor :dimension
+      delegate :dimension_definition, to: :dimension
+      delegate :name, to: :dimension, prefix: true
+      alias_method :name, :dimension_name             # Allows using #register for LevelCollection
+      alias_method :has_level?, :has_key?
+      alias_method :find_level, :find_or_error
+      alias_method :level_names, :keys
+      alias_method :level_objects, :values
+    end
+
+    # @param level_name [String, Symbol]
+    # @return [Integer]
+    def level_index(level_name)
+      to_a.index { |name, _object| name.to_s == level_name.to_s }
+    end
+
+    # @return [BaseLevelDefinition]
+    def level_above(level_name)
+      above_index = level_index(level_name) - 1
+      return nil if above_index < 0
+      values[above_index]
+    end
+
+    def level_below(level_name)
+      below_index = level_index(level_name) + 1
+      values[below_index]
+    end
+
+    # @param level_name [String, Symbol]
+    # @return [Array<Martyr::Level>] the first level of type `query` below the provided level
+    def query_level_below(level_name)
+      level_objects[level_index(level_name) + 1..-1].find{|level| level.query?}
+    end
+
+    # @param level_name [String, Symbol]
+    # @return [Array<Martyr::Level>] the provided level and all the levels above it
+    def level_and_above(level_name)
+      level_objects[0..level_index(level_name)]
+    end
+
+    # @param level_name [String, Symbol]
+    # @return [Array<Martyr::Level>] the provided level and all the levels below it
+    def level_and_below(level_name)
+      level_objects[level_index(level_name)..-1]
+    end
+
+    def lowest_level
+      values.max_by(&:to_i)
+    end
+
+  end
+end

data/lib/martyr/level_concern/level_comparator.rb

@@ -0,0 +1,45 @@
+module Martyr
+  module LevelComparator
+
+    # @param level1 [LevelAssociation, LevelDefinition nil]
+    # @param level2 [LevelAssociation, LevelDefinition, nil]
+    # @return [LevelAssociation, LevelDefinition, nil]
+    #   - nil if both nil
+    #   - level1 if level1 is "equal level" or "lower level" than level2, or if level2 is nil
+    #   - level2 if level2 is "lower level" than level1 or if level1 is nil
+    def more_detailed_level(level1, level2)
+      return nil unless level1 or level2
+      return level1 || level2 unless level1 and level2
+      return level1 if level1.to_i >= level2.to_i
+      level2
+    end
+
+
+    # @param level_definition [BaseLevelDefinition] must be level definition so that #level_and_below performs a full search
+    # @param level_associations_arr [Array<LevelAssociation>] of supported levels
+    # @option prefer_query [Boolean]
+    # @return [BaseLevelDefinition, nil]
+    #   prefer_query is false:
+    #       Finds the highest supported level in the cube that is equal or below level_definition.
+    #   prefer_query is true:
+    #       Finds the highest supported +query+ level in the cube that is equal or below level_definition.
+    #       If no such level exists, falls back on all levels.
+    #
+    def find_common_denominator_level(level_definition, level_associations_arr, prefer_query: false)
+      raise Internal::Error.new('level_definition must be level definition object') unless level_definition.is_a?(Schema::BaseLevelDefinition)
+      raise Internal::Error.new('level_associations_arr cannot be nil') unless level_associations_arr
+      supported_index = level_associations_arr.index_by(&:name)
+
+      levels_to_consider = level_associations_arr.select(&:query?).map(&:level).presence if prefer_query
+      levels_to_consider ||= level_definition.level_and_below
+      levels_to_consider.find{|l| supported_index[l.name] }
+    end
+
+    # @param levels [Array<Martyr::Level>]
+    # @return [Array<LevelDefinition>] lowest levels from the levels array in each dimension
+    def lowest_level_of(levels)
+      LevelDefinitionsByDimension.new(levels).lowest_levels
+    end
+
+  end
+end

data/lib/martyr/level_concern/level_definitions_by_dimension.rb

@@ -0,0 +1,24 @@
+module Martyr
+  class LevelDefinitionsByDimension
+
+    attr_reader :dimensions
+
+    # @param levels [Martyr::Level, Array<Martyr::Level>]
+    def initialize(levels = nil)
+      @dimensions = {}
+      Array.wrap(levels).each{|x| add_level(x)}
+    end
+
+    # @param level [Martyr::Level]
+    def add_level(level)
+      @dimensions[level.dimension_name] ||= {}
+      @dimensions[level.dimension_name][level.id] = level
+    end
+
+    def lowest_levels
+      dimensions.values.map do |levels_hash|
+        levels_hash.values.max_by(&:to_i)
+      end
+    end
+  end
+end