wonkavision 0.5.11 → 0.6.0

data/lib/wonkavision/plugins/analytics/cellset.rb

@@ -0,0 +1,171 @@
+require "set"
+
+module Wonkavision
+  module Analytics
+    class CellSet
+      attr_reader :axes, :query
+
+      def initialize(aggregation,query,tuples)
+        @axes = []
+        @query = query
+        dimension_members, @cells = process_tuples(aggregation, query, tuples)
+
+        query.axes.each do |axis_dimensions|
+          @axes << Axis.new(axis_dimensions,dimension_members,aggregation)
+        end
+      end
+
+      def columns; axes[0]; end
+      def rows; axes[1]; end
+      def pages; axex[2]; end
+      def chapters; axes[3]; end
+      def sections; axes[4]; end
+
+      def inspect
+        "<Cellset #{object_id} select:#{@query.selected_dimensions} where:#{@query.slicer}>"
+      end
+
+      def [](*coordinates)
+        key = coordinates.map{ |c|c.to_s }
+        @cells[key]
+      end
+
+      def length
+        @cells.length
+      end
+
+      private
+
+      def process_tuples(aggregation, query, tuples)
+        dims = {}
+        cells = {}
+        tuples.each do |record|
+          next unless query.matches_filter?(aggregation, record)
+          append_to_cell( cells, query, record )
+          record["dimension_names"].each_with_index do |dim_name,idx|
+            dim = dims[dim_name] ||= {}
+            dim_key = record["dimension_keys"][idx]
+            dim[dim_key] ||= record["dimensions"][dim_name]
+          end
+        end
+        [dims, cells]
+      end
+
+      def key_for(query,record)
+        key = []
+        query.selected_dimensions.each_with_index do |dim_name, idx|
+          dim_name = dim_name.to_s
+          dim_ordinal = record["dimension_names"].index(dim_name)
+          key << record["dimension_keys"][dim_ordinal]
+        end
+        key
+      end
+
+      def append_to_cell(cells, query, record)
+        #If a slicer is used for a dimension not on one of the main axes,
+        #then we'll have cases where more than one tuple needs to be
+        #stuck into a cell. In these cases, we need to aggregate
+        #the measure data for that cell on the fly
+        cell_key = key_for(query,record)
+        measures = record["measures"]
+
+        cell = cells[cell_key]
+        cell ? cell.aggregate(measures) : cells[cell_key] = Cell.new(cell_key,measures)
+      end
+
+      class Axis
+        attr_reader :dimensions
+        def initialize(dimensions,dimension_members,aggregation)
+          @dimensions = []
+          dimensions.each do |dim_name|
+            definition = aggregation.dimensions[dim_name]
+            members = dimension_members[dim_name.to_s]
+            @dimensions << Dimension.new(dim_name,definition,members)
+          end
+        end
+      end
+
+      class Dimension
+        attr_reader :definition,:members,:name
+        def initialize(name,definition,members)
+          @name = name.to_s
+          @definition = definition
+          @members = members ? members.values.map{ |mem_data| Member.new(self,mem_data)}.sort : []
+        end
+      end
+
+      class Member
+        attr_reader :dimension, :attributes
+        def initialize(dimension,member_data)
+          @dimension = dimension
+          @attributes = member_data
+        end
+        def caption
+          attributes[dimension.definition.caption.to_s]
+        end
+        def key
+          attributes[dimension.definition.key.to_s]
+        end
+        def sort
+          attributes[dimension.definition.sort.to_s]
+        end
+        def <=>(other)
+          sort <=> other.sort
+        end
+        def to_s
+          key.to_s
+        end
+      end
+
+      class Cell
+        attr_reader :key
+        attr_reader :measures
+        def initialize(key,measure_data)
+          @key = key
+          @measures = HashWithIndifferentAccess.new
+          measure_data.each_pair do |measure_name,measure|
+            @measures[measure_name] = Measure.new(measure_name,measure)
+          end
+        end
+        def aggregate(measure_data)
+          measure_data.each_pair do |measure_name,measure_data|
+            measure = @measures[measure_name]
+            measure ? measure.aggregate(measure_data) :
+              @measures[measure_name] = Measure.new(measure_name,measure)
+          end
+        end
+        def method_missing(method,*args)
+          measures[method] || super
+        end
+      end
+
+      class Measure
+        attr_reader :name, :data
+        def initialize(name,data)
+          @name = name
+          @data = data
+        end
+
+        def sum; @data["sum"]; end
+        def sum2; @data["sum2"]; end
+        def count; @data["count"]; end
+
+        def mean; sum/count; end
+        alias :average :mean
+
+        def std_dev
+          return Wonkavision::NaN unless count > 1
+           Math.sqrt((sum2.to_f - ((sum.to_f * sum.to_f)/count.to_f)) / (count.to_f - 1))
+        end
+
+        def aggregate(new_data)
+          @data["sum"] = @data["sum"].to_f + new_data["sum"].to_f
+          @data["sum2"] = @data["sum2"].to_f + new_data["sum2"].to_f
+          @data["count"] = @data["count"].to_i + new_data["count"].to_i
+        end
+
+      end
+
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/facts.rb

@@ -0,0 +1,106 @@
+require "set"
+
+module Wonkavision
+  module Plugins
+    module Facts
+
+      def self.configure(facts, options ={})
+        facts.write_inheritable_attribute :facts_options, options
+        facts.class_inheritable_reader :facts_options
+
+        facts.write_inheritable_attribute :aggregations, []
+        facts.class_inheritable_reader :aggregations
+      end
+
+      module ClassMethods
+
+        def output_event_path(new_path=nil)
+          if new_path
+            facts_options[:output_event_path] = new_path
+          else
+            facts_options[:output_event_path] ||=
+              Wonkavision.join('wv','analytics','facts','updated')
+          end
+        end
+
+        def accept(event_path, options={}, &mapping_block)
+          map(event_path, &mapping_block) if mapping_block
+          handle event_path do
+            accept_event(event_context.data, options)
+          end
+        end
+
+        def record_id(new_record_id=nil)
+          if new_record_id
+            facts_options[:record_id] = new_record_id
+          else
+            facts_options[:record_id] ||= "id"
+          end
+        end
+
+        def store(new_store=nil)
+          if new_store
+            store = new_store.kind_of?(Wonkavision::Analytics::Persistence::Store) ? store :
+              Wonkavision::Analytics::Persistence::Store[new_store]
+
+            raise "Could not find a storage type of #{new_store}" unless store
+
+            store = store.new(self) if store.respond_to?(:new)
+
+            facts_options[:store] = store
+          else
+            facts_options[:store]
+          end
+        end
+
+      end
+
+      module InstanceMethods
+        def accept_event(event_data, options={})
+          action = options[:action] || :add
+          send "#{action}_facts", event_data
+        end
+
+        def update_facts(data)
+          raise "A persistent store must be configured in order to update facts" unless store
+
+          previous_facts, current_facts = store.update_facts(data)
+          unless previous_facts == current_facts
+            process_facts previous_facts, "reject" if previous_facts
+            process_facts current_facts, "add" if current_facts
+          end
+        end
+
+        def add_facts(data)
+          current_facts = store ? store.add_facts(data) : data
+          process_facts current_facts, "add" if current_facts
+        end
+
+        def reject_facts(data)
+          previous_facts = store ? store.remove_facts(data) : data
+          process_facts previous_facts, "reject" if previous_facts
+        end
+
+        protected
+
+        def store
+          self.class.store
+        end
+
+        #It is unnecessary to accept multiple actions - this should be removed
+        def process_facts(event_data, *actions)
+          actions.each do |action|
+            self.class.aggregations.each do |aggregation|
+              submit self.class.output_event_path, {
+                "action" => action,
+                "aggregation" => aggregation.name,
+                "data" => event_data
+              }
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/handlers/apply_aggregation.rb

@@ -0,0 +1,35 @@
+module Wonkavision
+  module Analytics
+    class ApplyAggregation
+      include Wonkavision::EventHandler
+
+      event_namespace Wonkavision.join('wv', 'analytics')
+
+      handle Wonkavision.join('aggregation', 'updated') do
+        process_event(event_context.data)
+      end
+
+      def process_event(event)
+        return false unless
+          (aggregation = aggregation_for(event["aggregation"])) &&
+          (action = event["action"]) &&
+          (measures = event["measures"]) &&
+          (dimensions = event["dimensions"])
+
+        raise "The only valid values for 'action' on an aggregation.updated message are 'add' and 'reject', #{action} was encountered. Message: #{event.inspect}" unless ["add", "reject"].include?(action.to_s)
+
+        #Don't bother to continue if the measures are all nil
+        if measures.values.detect{|m|m}
+          action.to_s == "add" ? aggregation[dimensions].add(measures) :
+            aggregation[dimensions].reject(measures)
+        end
+
+      end
+
+      def aggregation_for(aggregation_name)
+        Wonkavision::Aggregation.all[aggregation_name]
+      end
+
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/handlers/split_by_aggregation.rb

@@ -0,0 +1,60 @@
+module Wonkavision
+  module Analytics
+    class SplitByAggregation
+      include Wonkavision::EventHandler
+
+      event_namespace Wonkavision.join('wv', 'analytics')
+
+      handle Wonkavision.join('facts', 'updated') do
+        process_event(event_context.data)
+      end
+
+      def process_event(event)
+        return false unless
+          (aggregation = aggregation_for(event["aggregation"])) &&
+          (action = event["action"]) &&
+          (entity = event["data"])
+
+        return [] unless aggregation.matches(entity)
+
+        measures = aggregation.measures.keys.inject({}) do |measures,measure|
+          measures[measure] = entity[measure.to_s]
+          measures
+        end
+
+        messages = split_dimensions_by_aggregation(aggregation,entity).map do |dimensions|
+          {
+            "action" => action,
+            "aggregation" => aggregation.name,
+            "dimensions" => dimensions,
+            "measures" => measures
+          }
+        end
+        process_aggregations messages
+      end
+
+      def process_aggregations(messages)
+        messages = [messages].flatten
+        event_path = self.class.event_path( Wonkavision.join('aggregation', 'updated') )
+        messages.each {  |message| submit(event_path, message) }
+        messages
+      end
+
+      def split_dimensions_by_aggregation(aggregation,entity)
+        aggregation.aggregations.inject([]) do |aggregations,aggregate_by|
+          aggregations << aggregate_by.inject({}) do |dimensions,dimension_name|
+            dimension = aggregation.dimensions[dimension_name]
+            dimensions[dimension_name.to_s] = dimension.extract(entity)
+            dimensions
+          end
+          aggregations
+        end
+      end
+
+      def aggregation_for(aggregation_name)
+        Wonkavision::Aggregation.all[aggregation_name]
+      end
+
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/member_filter.rb

@@ -0,0 +1,106 @@
+module Wonkavision
+  module Analytics
+    class MemberFilter
+
+      attr_reader :name, :operator, :member_type
+      attr_accessor :value
+
+      def initialize(member_name, options={})
+        @name = member_name
+        @attribute_name = options[:attribute_name]
+        @operator = options[:operator] || options[:op] || :eq
+        @member_type = options[:member_type] || :dimension
+        @value = options[:value]
+        @applied = false
+      end
+
+      def attribute_name
+        @attribute_name ||= dimension? ? :key : :count
+      end
+
+      def dimension?
+        member_type == :dimension
+      end
+
+      def measure?
+        member_type == :measure
+      end
+
+      def applied!
+        @applied = true
+      end
+
+      def applied?
+        @applied
+      end
+
+      [:gt, :lt, :gte, :lte, :ne, :in, :nin, :eq].each do |operator|
+        define_method(operator) do |*args|
+         @value = args[0] if args.length > 0
+         @operator = operator; self
+        end unless method_defined?(operator)
+      end
+
+      def matches(aggregation, tuple)
+        #this check allows the database adapter to apply a filter at the db query level
+        #Wonkavision will avoid the overhead of checking again if the store signals it has taken care of things
+        return true if @applied || tuple.blank?
+
+        assert_operator_matches_value
+
+        data = extract_attribute_value_from_tuple(aggregation, tuple)
+
+        case operator
+        when :gt then data ? data > value : false
+        when :lt then data ? data < value : false
+        when :gte then data ? data >= value : false
+        when :lte then data ? data <= value : false
+        when :in then value.include?(data)
+        when :nin then !value.include?(data)
+        when :ne then data != value
+        when :eq then value == data
+        else raise "Unknown filter operator #{operator}"
+        end
+      end
+
+      def attribute_key(aggregation)
+        attribute_key = attribute_name.to_s
+        #If the attribute name is key, caption or sort, we need to find the real name of the underling
+        # attribute
+        if dimension?
+          dimension = aggregation.dimensions[name]
+          raise "Error applying a member filter: Dimension #{name} does not exist" unless dimension
+          attribute_key = dimension.send(attribute_name).to_s if dimension.respond_to?(attribute_name)
+        end
+        attribute_key
+      end
+
+      private
+
+      # TODO: This is smelly - we should have a Tuple class that knows its aggregation
+      # and can return this kind of information on demand - it is dirty business
+      # that a filter class has to know the about the anatomy of a tuple to do its
+      # job
+      def extract_attribute_value_from_tuple(aggregation,tuple)
+        val = tuple["#{member_type}s"] #dimensions or measures
+        val = val[name.to_s] #measure name or dimension name
+
+        if val
+          val[attribute_key(aggregation)]
+        end
+      end
+
+      def assert_operator_matches_value
+
+        case operator
+        when :gt, :lt, :gte, :lte then
+          raise "A filter value is required for #{operator}" unless value
+        when :in, :nin then
+          raise "A filter value is required for #{operator}" unless value
+          raise "The filter value for #{operator} must respond to :include?" unless value.respond_to?(:include?)
+        end
+      end
+
+    end
+  end
+end