wonkavision 0.5.11 → 0.6.0

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

@@ -0,0 +1,6 @@
+dir = File.dirname(__FILE__)
+[
+ '../../persistence/mongo',
+ 'persistence/mongo_store.rb'
+
+].each {|lib|require File.join(dir,lib)}

data/lib/wonkavision/plugins/analytics/persistence/hash_store.rb

@@ -0,0 +1,59 @@
+module Wonkavision
+  module Analytics
+    module Persistence
+      class HashStore < Store
+
+        attr_reader :storage
+        def initialize(facts, storage = HashWithIndifferentAccess.new)
+          super(facts)
+          @storage = storage
+        end
+
+        def aggregations
+          @storage[:aggregations] ||= {}
+        end
+
+        protected
+        #Fact persistence
+        def update_facts_record(record_id, data)
+          previous_facts = @storage[record_id]
+          current_facts = @storage[record_id] = (previous_facts ||  {}).merge(data)
+          [previous_facts, current_facts]
+        end
+
+        def insert_facts_record(record_id, data)
+          @storage[record_id] = data
+        end
+
+        def delete_facts_record(record_id, data)
+          @storage.delete(record_id)
+        end
+
+        #Aggregation persistence
+        def fetch_tuples(dimension_names = [], filters = [])
+          return aggregations.values if dimension_names.blank?
+          tuples = []
+          aggregations.each_pair do |agg_key, agg|
+            tuples << agg if
+              agg_key[:dimension_names] == dimension_names
+          end
+          tuples
+        end
+
+        def update_tuple(data)
+          key = aggregation_key(data)
+          agg = aggregations[key]
+          if agg
+            data[:measures].keys.each do |measure_key|
+              agg[:measures][measure_key] ||= 0
+              agg[:measures][measure_key] += data[:measures][measure_key]
+            end
+          else
+            aggregations[key] = data.dup
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/persistence/mongo_store.rb

@@ -0,0 +1,85 @@
+module Wonkavision
+  module Analytics
+    module Persistence
+      class MongoStore < Store
+
+        def initialize(facts)
+          super(facts)
+        end
+
+        def facts_collection_name
+          "wv.#{owner.name.underscore.gsub("::",".")}.facts"
+        end
+
+        def facts_collection
+          Wonkavision::Mongo.database[facts_collection_name]
+        end
+
+        def aggregations_collection_name
+          "wv.#{owner.name.underscore.gsub("::",".")}.aggregations"
+        end
+
+        def aggregations_collection
+          Wonkavision::Mongo.database[aggregations_collection_name]
+        end
+
+        def[](document_id)
+          facts_collection.find({ :_id => document_id}).to_a.pop
+        end
+
+
+        protected
+        #Fact persistence
+        def update_facts_record(record_id, data)
+          query = { :_id => record_id }
+          update = { "$set" => data }
+          previous_facts = facts_collection.find_and_modify :query=>query, :update=>update, :upsert=>true
+          current_facts = (previous_facts || {}).merge(data)
+          remove_mongo_id(previous_facts, current_facts)
+        end
+
+        def insert_facts_record(record_id, data)
+          query = { :_id => record_id }
+          facts_collection.update(query, data.merge(:_id=>record_id), :upsert=>true)
+          data
+        end
+
+        def delete_facts_record(record_id, data)
+          query = { :_id => record_id }
+          remove_mongo_id(facts_collection.find_and_modify(:query=>query, :remove=>true))
+        end
+
+        #Aggregation persistence
+        def fetch_tuples(dimension_names, filters)
+          criteria = dimension_names.blank? ? {} : { :dimension_names => dimension_names }
+          append_filters(criteria,filters)
+          aggregations_collection.find(criteria).to_a
+        end
+
+        def update_tuple(data)
+          aggregations_collection.update( aggregation_key(data),
+                                          {"$inc" => data[:measures],
+                                            "$set" => { :dimensions=>data[:dimensions]}},
+                                          :upsert => true, :safe => true )
+        end
+
+        def remove_mongo_id(*documents)
+          unless owner.respond_to?(:record_id) && owner.record_id.to_s == "_id"
+            documents.each { |doc| doc.delete("_id")}
+          end
+          documents.length > 1 ? documents : documents.pop
+        end
+
+        private
+        def append_filters(criteria,filters)
+          filters.each do |filter|
+            filter_key = "#{filter.member_type}s.#{filter.name}.#{filter.attribute_key(owner)}"
+            criteria[filter_key] = filter.operator == :eq ? filter.value :
+              { "$#{filter.operator}" => filter.value}
+            filter.applied!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wonkavision/plugins/analytics/persistence/store.rb

@@ -0,0 +1,105 @@
+module Wonkavision
+  module Analytics
+    module Persistence
+      class Store
+
+        def self.[](store_name)
+          @stores ||= {}
+          @stores[store_name.to_s]
+        end
+
+        def self.[]=(store_name,store)
+          @stores ||= {}
+          @stores[store_name.to_s] = store
+        end
+
+        def self.inherited(store)
+          store_name = store.name.split("::").pop.underscore
+          self[store_name] = store
+        end
+
+        attr_reader :owner
+        def initialize(owner)
+          @owner = owner
+        end
+
+        #Facts persistence support
+        #
+        # returns a two element array, the first element
+        # containing the prior state of the facts record,
+        # the second element containing the current state
+        # of the facts record
+        def update_facts(data)
+          record_id = assert_record_id(data)
+          update_facts_record record_id, data
+        end
+
+        #returns the current value of the facts record
+        def add_facts(data)
+          record_id = assert_record_id(data)
+          insert_facts_record record_id, data
+        end
+
+        #returns the previous value of the facts record
+        def remove_facts(data)
+          record_id = assert_record_id(data)
+          delete_facts_record record_id, data
+        end
+
+        #Aggregations persistence support
+        #
+        # Takes a Wonkavision::Analytics::Query and returns an array of
+        # matching tuples
+        def execute_query(query)
+          dimension_names = query.all_dimensions? ? [] :
+            query.referenced_dimensions.sort{ |a,b| a.to_s <=> b.to_s }
+
+          fetch_tuples(dimension_names, query.filters)
+
+        end
+
+        def update_aggregation(aggregation_data)
+          update_tuple(aggregation_data)
+        end
+
+        protected
+
+        def assert_record_id(data)
+          raise "The storage owner does not implement a 'record_id' method. (#{owner.inspect})" unless owner.respond_to?(:record_id)
+
+          data[owner.record_id.to_s].tap do |id|
+            raise "A record_id is required to update the analytics store" unless id
+          end
+        end
+
+        def aggregation_key(aggregation_data)
+          {
+            :dimension_keys => aggregation_data[:dimension_keys],
+            :dimension_names => aggregation_data[:dimension_names]
+          }
+        end
+        #Abstract methods
+        def update_facts_record(record_id, data)
+          raise NotImplementedError
+        end
+
+        def insert_facts_record(record_id, data)
+          raise NotImplementedError
+        end
+
+        def fetch_tuples(dimension_names, filters = [])
+          raise NotImplementedError
+        end
+
+        def update_tuple(aggregation_data)
+          raise NotImplementedError
+        end
+
+        def  delete_facts_record(record_id, data)
+          raise NotImplementedError
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Wonkavision
+  module Analytics
+    class Query
+      attr_reader :axes, :filters
+
+      def initialize()
+        @axes = []
+        @slicer = Set.new
+        @filters = []
+      end
+
+      def select(*dimensions)
+        options = dimensions.extract_options!
+        axis = options[:axis] || options[:on]
+        axis_ordinal = self.class.axis_ordinal(axis)
+        @axes[axis_ordinal] = dimensions
+        self
+      end
+
+      def where(criteria_hash = {})
+        criteria_hash.each_pair do |filter,value|
+          member_filter = filter.kind_of?(MemberFilter) ? filter :
+            MemberFilter.new(filter)
+          member_filter.value = value
+          @filters << member_filter
+          @slicer << member_filter.name if member_filter.dimension?
+        end
+        self
+      end
+
+      def slicer
+        dims = selected_dimensions
+        @slicer.reject{|m|dims.include?(m)}
+      end
+
+      def referenced_dimensions
+        ( [] + selected_dimensions + slicer ).compact
+      end
+
+      def selected_dimensions
+        dimensions = []
+        axes.each { |dims|dimensions.concat(dims) unless dims.blank? }
+        dimensions.uniq.compact
+      end
+
+      def all_dimensions?
+        axes.empty?
+      end
+
+      def matches_filter?(aggregation, tuple)
+        return true if all_filters_applied?
+        !( filters.detect{ |filter| !filter.matches(aggregation, tuple) } )
+      end
+
+      def all_filters_applied?
+        @all_filters_applied ||= !(filters.detect{ |filter| !filter.applied? })
+      end
+
+      def validate!
+        axes.each_with_index{|axis,index|raise "Axes must be selected from in consecutive order and contain at least one dimension. Axis #{index} is blank." if axis.blank?}
+      end
+
+      def self.axis_ordinal(axis_def)
+        case axis_def.to_s.strip.downcase.to_s
+        when "columns" then 0
+        when "rows" then 1
+        when "pages" then 2
+        when "chapters" then 3
+        when "sections" then 4
+        else axis_def.to_i
+        end
+      end
+
+    end
+  end
+end

data/lib/wonkavision/plugins/event_handling.rb

@@ -69,7 +69,7 @@ module Wonkavision
         def event_context
           @wonkavision_event_context
         end
-        
+
         def handle_event
           ctx = @wonkavision_event_context
           ctx.data = map(ctx.data,ctx.path)
@@ -97,13 +97,25 @@ module Wonkavision
 
         def map?(condition,data,path)
           return true unless condition && condition.to_s != 'all' && condition.to_s != '*'
-          return path =~ condition if condition.is_a?(Regexp)
-          if (condition.is_a?(Proc))
+
+          if condition.is_a?(Regexp)
+            path =~ condition
+          elsif condition.is_a?(String)
+            path.downcase == condition.downcase
+          elsif condition.is_a?(Proc)
             return condition.call if condition.arity  <= 0
             return condition.call(path) if condition.arity == 1
             return condition.call(path,data)
           end
         end
+
+        def broadcast(event_name, event)
+          Wonkavision.event_coordinator.publish(event_name, event)
+        end
+
+        def submit(event_name, event)
+          Wonkavision.event_coordinator.submit_job(event_name, event)
+        end
       end
 
     end

data/lib/wonkavision/version.rb

@@ -1,3 +1,3 @@
 module Wonkavision
-  VERSION = '0.5.11'
+  VERSION = '0.6.0'
 end

data/test/aggregation_spec_test.rb

@@ -0,0 +1,99 @@
+require "test_helper"
+
+class AggregationSpecTest < ActiveSupport::TestCase
+  context "AggregationSpec" do
+    setup do
+      @aggregation_spec = Wonkavision::Plugins::Aggregation::AggregationSpec.new("MyAggregation")
+    end
+
+    should "take its name from the constructor" do
+      assert_equal "MyAggregation", @aggregation_spec.name
+    end
+
+    context "#dimension" do
+      setup do
+        @aggregation_spec.dimension :a, :b, :c=>"d"
+      end
+
+      should "add a dimension for each provided value" do
+        assert_equal 2, @aggregation_spec.dimensions.length
+        ["a","b"].each { |dim| assert @aggregation_spec.dimensions.keys.include?(dim)}
+      end
+
+      should "store pass the options to each dimension" do
+        @aggregation_spec.dimensions.values.each { |dim| assert_equal({:c=>"d"},dim.options)}
+      end
+    end
+
+    context "#measure" do
+      setup do
+        @aggregation_spec.measure :c, :d, :e => "f"
+      end
+
+      should "add a measure for each provided value" do
+        assert_equal 2, @aggregation_spec.measures.length
+      end
+
+      should "add the attributes as hash elements" do
+        [:c, :d].each { |measure| assert @aggregation_spec.measures[measure]}
+      end
+
+      should "store the options to each measure" do
+        @aggregation_spec.measures.each_pair { |k,v| assert_equal({ "e" => "f"}, v)}
+      end
+    end
+
+    context "#aggregate_by" do
+      setup do
+        @aggregation_spec.aggregate_by :a, :b
+        @aggregation_spec.aggregate_by :a, :c
+        @aggregation_spec.aggregate_by [:a, :c, :d]
+      end
+
+      should "append the list of aggregations to the aggregations collection" do
+        assert_equal 3, @aggregation_spec.aggregations.length
+      end
+
+      should "append the list of aggregations as a simple array" do
+        assert_equal [:a, :b], @aggregation_spec.aggregations[0]
+      end
+
+      should "flatten arrays of attributes" do
+        assert_equal [:a, :c, :d], @aggregation_spec.aggregations[-1]
+      end
+    end
+
+    context "#aggregate_all_combinations" do
+      setup do
+        @aggregation_spec.dimension :a,:b,:c
+        @aggregation_spec.aggregate_all_combinations
+      end
+      should "determine all possible combinations of dimensions" do
+        assert_equal 7, @aggregation_spec.aggregations.length
+        combinations = [["a"], ["b"], ["c"], ["a", "b"], ["a", "c"], ["b", "c"], ["a", "b", "c"]]
+        assert_equal combinations, @aggregation_spec.aggregations
+      end
+    end
+
+    context "#filter" do
+      setup do
+        @aggregation_spec.filter { |msg|msg["a"] == "b"}
+      end
+      should "register a filter block with the spec" do
+        assert_not_nil @aggregation_spec.filter
+      end
+    end
+    context "#matches" do
+      setup do
+        @aggregation_spec.filter { |msg| msg["a"] == "b"}
+      end
+      should "return true if a message matches the filter" do
+        assert @aggregation_spec.matches({ "a" => "b"})
+      end
+      should "return false if the message does not match the filter" do
+        assert !@aggregation_spec.matches({ "a" => "B"})
+      end
+    end
+
+  end
+end