wonkavision 0.5.4 → 0.5.9

data/lib/wonkavision/plugins/event_handling.rb

@@ -1,111 +1,111 @@
-module Wonkavision
-  module Plugins
-    module EventHandling
-
-      def self.configure(handler,options)
-        handler.write_inheritable_attribute :event_handler_options, {}
-        handler.class_inheritable_reader :event_handler_options
-
-        handler.write_inheritable_attribute :bindings, []
-        handler.class_inheritable_reader :bindings
-
-        handler.write_inheritable_attribute :maps, []
-        handler.class_inheritable_reader :maps
-
-      end
-
-      module ClassMethods
-        def options
-          event_handler_options
-        end
-
-        def event_path(event_name)
-          return event_name.to_s if Wonkavision.is_absolute_path(event_name) #don't mess with an absolute path
-          Wonkavision.join(event_namespace,event_name)
-        end
-
-        def event_namespace(namespace=nil)
-          return event_handler_options[:event_namespace] unless namespace
-          event_handler_options[:event_namespace] = namespace
-        end
-        alias :namespace :event_namespace
-
-        def map(condition = nil,&block)
-          maps << [condition,block]
-        end
-
-        def handle(name,*args,&block)
-          binding = create_binding(name,self,*args)
-          binding.subscribe_to_events do |event_data,event_path|
-            ctx = Wonkavision::EventContext.new(event_data,event_path,binding,block)
-            handler = instantiate_handler(ctx)
-            handler.instance_variable_set(:@wonkavision_event_context, ctx)
-            handler.handle_event
-          end
-          bindings << binding
-          binding
-        end
-
-        def instantiate_handler(event_context)
-          self.new
-        end
-
-        def create_binding(name,handler,*args)
-          Wonkavision::EventBinding.new(name,handler,*args)
-        end
-
-      end
-
-      module InstanceMethods
-
-        def handled?
-          @wonkavision_event_handled ||= false
-        end
-
-        def handled=(handled)
-          @wonkavision_event_handled = handled
-        end
-
-        def event_context
-          @wonkavision_event_context
-        end
-        
-        def handle_event
-          ctx = @wonkavision_event_context
-          ctx.data = map(ctx.data,ctx.path)
-          handler = ctx.callback
-
-          if handler && handler.respond_to?(:call) && handler.respond_to?(:arity)
-              case handler.arity
-              when 3 then handler.call(ctx.data,ctx.path,self)
-              when 2 then handler.call(ctx.data,ctx.path)
-              when 1 then handler.call (ctx.data)
-              else instance_eval &handler
-            end
-          end
-        end
-
-        protected
-        def map(data,path)
-          self.class.maps.each do |map_def|
-            condition = map_def[0]
-            map_block = map_def[1]
-            return Wonkavision::MessageMapper.execute(map_block,data) if map?(condition,data,path)
-          end
-          data.is_a?(Hash) ? data.dup : data
-        end
-
-        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))
-            return condition.call if condition.arity  <= 0
-            return condition.call(path) if condition.arity == 1
-            return condition.call(path,data)
-          end
-        end
-      end
-
-    end
-  end
-end
+module Wonkavision
+  module Plugins
+    module EventHandling
+
+      def self.configure(handler,options)
+        handler.write_inheritable_attribute :event_handler_options, {}
+        handler.class_inheritable_reader :event_handler_options
+
+        handler.write_inheritable_attribute :bindings, []
+        handler.class_inheritable_reader :bindings
+
+        handler.write_inheritable_attribute :maps, []
+        handler.class_inheritable_reader :maps
+
+      end
+
+      module ClassMethods
+        def options
+          event_handler_options
+        end
+
+        def event_path(event_name)
+          return event_name.to_s if Wonkavision.is_absolute_path(event_name) #don't mess with an absolute path
+          Wonkavision.join(event_namespace,event_name)
+        end
+
+        def event_namespace(namespace=nil)
+          return event_handler_options[:event_namespace] unless namespace
+          event_handler_options[:event_namespace] = namespace
+        end
+        alias :namespace :event_namespace
+
+        def map(condition = nil,&block)
+          maps << [condition,block]
+        end
+
+        def handle(name,*args,&block)
+          binding = create_binding(name,self,*args)
+          binding.subscribe_to_events do |event_data,event_path|
+            ctx = Wonkavision::EventContext.new(event_data,event_path,binding,block)
+            handler = instantiate_handler(ctx)
+            handler.instance_variable_set(:@wonkavision_event_context, ctx)
+            handler.handle_event
+          end
+          bindings << binding
+          binding
+        end
+
+        def instantiate_handler(event_context)
+          self.new
+        end
+
+        def create_binding(name,handler,*args)
+          Wonkavision::EventBinding.new(name,handler,*args)
+        end
+
+      end
+
+      module InstanceMethods
+
+        def handled?
+          @wonkavision_event_handled ||= false
+        end
+
+        def handled=(handled)
+          @wonkavision_event_handled = handled
+        end
+
+        def event_context
+          @wonkavision_event_context
+        end
+        
+        def handle_event
+          ctx = @wonkavision_event_context
+          ctx.data = map(ctx.data,ctx.path)
+          handler = ctx.callback
+
+          if handler && handler.respond_to?(:call) && handler.respond_to?(:arity)
+              case handler.arity
+              when 3 then handler.call(ctx.data,ctx.path,self)
+              when 2 then handler.call(ctx.data,ctx.path)
+              when 1 then handler.call(ctx.data)
+              else instance_eval &handler
+            end
+          end
+        end
+
+        protected
+        def map(data,path)
+          self.class.maps.each do |map_def|
+            condition = map_def[0]
+            map_block = map_def[1]
+            return Wonkavision::MessageMapper.execute(map_block,data) if map?(condition,data,path)
+          end
+          data.is_a?(Hash) ? data.dup : data
+        end
+
+        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))
+            return condition.call if condition.arity  <= 0
+            return condition.call(path) if condition.arity == 1
+            return condition.call(path,data)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/wonkavision/plugins/timeline.rb

@@ -1,80 +1,80 @@
-module Wonkavision
-  module Plugins
-    module Timeline
-      def self.all
-        @@all ||= []
-      end
-
-      def self.configure(activity,options={})
-        activity.ensure_wonkavision_plugin(Wonkavision::Plugins::BusinessActivity,options)
-        activity.write_inheritable_attribute :timeline_milestones, []
-        activity.class_inheritable_reader :timeline_milestones
-
-        options = {
-                          :timeline_field => "timeline",
-                          :latest_milestone_field => "latest_milestone",
-                          :event_time_key => "event_time"
-        }.merge(options)
-
-        activity.business_activity_options.merge!(options)
-
-        activity.define_document_key(activity.timeline_field,Hash,:default=>{})
-        activity.define_document_key(activity.latest_milestone_field, String, :default=>"awaiting_first_event")
-
-        Timeline.all << activity
-      end
-
-      module ClassMethods
-
-        def milestone(name,*args)
-          timeline_milestones << event(name,*args) do
-            ctx = @wonkavision_event_context
-            event_time = self.class.extract_event_time(ctx.data,ctx.path)
-            prev_event_time = self[timeline_field][name]
-            unless prev_event_time
-              self[timeline_field][name] = event_time
-              #If the event being processed happened earlier than a previously
-              #recorded event, we don't want to overwrite state of the activity, as
-              #it is already more up to date than the incoming event.
-              latest_ms = self[latest_milestone_field]
-              unless latest_ms &&
-                             (last_event = self[timeline_field][latest_ms]) &&
-                             last_event > event_time
-                self.class.update_activity(self,ctx.data)
-                self[latest_milestone_field] = name
-              end
-              :updated
-            else
-              :handled #If there was a previous event time for this milestone, we will just skip this event
-            end
-          end
-        end
-
-        def convert_time(time)
-          if (time.is_a?(Hash)) && (time.keys.include?(:date) || time.keys.include?(:time))
-            time = "#{time[:date]} #{time[:time]}".strip
-          end
-          time ? time.to_time : nil
-        end
-
-        def extract_event_time(event_data,event_path)
-          convert_time(event_data.delete(event_time_key.to_s)) || Time.now.utc
-        end
-      end
-
-      module Fields
-        def timeline_field
-          business_activity_options[:timeline_field]
-        end
-
-        def latest_milestone_field
-          business_activity_options[:latest_milestone_field]
-        end
-
-        def event_time_key
-          business_activity_options[:event_time_key]
-        end
-      end
-    end
-  end
+module Wonkavision
+  module Plugins
+    module Timeline
+      def self.all
+        @@all ||= []
+      end
+
+      def self.configure(activity,options={})
+        activity.ensure_wonkavision_plugin(Wonkavision::Plugins::BusinessActivity,options)
+        activity.write_inheritable_attribute :timeline_milestones, []
+        activity.class_inheritable_reader :timeline_milestones
+
+        options = {
+                          :timeline_field => "timeline",
+                          :latest_milestone_field => "latest_milestone",
+                          :event_time_key => "event_time"
+        }.merge(options)
+
+        activity.business_activity_options.merge!(options)
+
+        activity.define_document_key(activity.timeline_field,Hash,:default=>{})
+        activity.define_document_key(activity.latest_milestone_field, String, :default=>"awaiting_first_event")
+
+        Timeline.all << activity
+      end
+
+      module ClassMethods
+
+        def milestone(name,*args)
+          timeline_milestones << event(name,*args) do
+            ctx = @wonkavision_event_context
+            event_time = self.class.extract_event_time(ctx.data,ctx.path)
+            prev_event_time = self[timeline_field][name]
+            unless prev_event_time
+              self[timeline_field][name] = event_time
+              #If the event being processed happened earlier than a previously
+              #recorded event, we don't want to overwrite state of the activity, as
+              #it is already more up to date than the incoming event.
+              latest_ms = self[latest_milestone_field]
+              unless latest_ms &&
+                             (last_event = self[timeline_field][latest_ms]) &&
+                             last_event > event_time
+                self.class.update_activity(self,ctx.data)
+                self[latest_milestone_field] = name
+              end
+              :updated
+            else
+              :handled #If there was a previous event time for this milestone, we will just skip this event
+            end
+          end
+        end
+
+        def convert_time(time)
+          if (time.is_a?(Hash)) && (time.keys.include?(:date) || time.keys.include?(:time))
+            time = "#{time[:date]} #{time[:time]}".strip
+          end
+          time ? time.to_time : nil
+        end
+
+        def extract_event_time(event_data,event_path)
+          convert_time(event_data.delete(event_time_key.to_s)) || Time.now.utc
+        end
+      end
+
+      module Fields
+        def timeline_field
+          business_activity_options[:timeline_field]
+        end
+
+        def latest_milestone_field
+          business_activity_options[:latest_milestone_field]
+        end
+
+        def event_time_key
+          business_activity_options[:event_time_key]
+        end
+      end
+    end
+  end
 end

data/lib/wonkavision/version.rb

@@ -1,3 +1,3 @@
-module Wonkavision
-  VERSION = '0.5.4'
-end
+module Wonkavision
+  VERSION = '0.5.9'
+end

data/test/business_activity_test.rb

@@ -1,31 +1,31 @@
-require "test_helper"
-require "test_activity_models"
-
-class BusinessActivityTest < ActiveSupport::TestCase
-  context "TestBusinessActivity" do
-    should "configure namespace from DSL" do
-      assert_equal :test, TestBusinessActivity.event_namespace
-    end
-    should "configure correlation identifiers from DSL" do
-      assert_equal({:event=>:test_id, :model=>:test_id}, TestBusinessActivity.correlate_by)
-    end
-    should "register activity with global registry" do
-      assert_equal 1, Wonkavision::Plugins::BusinessActivity.all.length
-      assert_equal TestBusinessActivity, Wonkavision::Plugins::BusinessActivity.all[0]
-    end
-
-    should "register correlation ids with each activity" do
-      ids =  Wonkavision::Plugins::BusinessActivity.all[0].correlation_ids
-      assert_equal 1, ids.length
-      assert_equal :test_id, ids[0][:event]
-    end
-
-    should "use per binding correlation ids when specified" do
-      event = {"alt_event_id"=>"123","another_field"=>"hi there"}
-      Wonkavision.event_coordinator.receive_event("test/evt5",event)
-      assert activity = TestBusinessActivity.find_by_alt_model_id("123")
-      assert_equal "hi there", activity.another_field
-    end
-    
-  end
-end
+require "test_helper"
+require "test_activity_models"
+
+class BusinessActivityTest < ActiveSupport::TestCase
+  context "TestBusinessActivity" do
+    should "configure namespace from DSL" do
+      assert_equal :test, TestBusinessActivity.event_namespace
+    end
+    should "configure correlation identifiers from DSL" do
+      assert_equal({:event=>:test_id, :model=>:test_id}, TestBusinessActivity.correlate_by)
+    end
+    should "register activity with global registry" do
+      assert_equal 1, Wonkavision::Plugins::BusinessActivity.all.length
+      assert_equal TestBusinessActivity, Wonkavision::Plugins::BusinessActivity.all[0]
+    end
+
+    should "register correlation ids with each activity" do
+      ids =  Wonkavision::Plugins::BusinessActivity.all[0].correlation_ids
+      assert_equal 1, ids.length
+      assert_equal :test_id, ids[0][:event]
+    end
+
+    should "use per binding correlation ids when specified" do
+      event = {"alt_event_id"=>"123","another_field"=>"hi there"}
+      Wonkavision.event_coordinator.receive_event("test/evt5",event)
+      assert activity = TestBusinessActivity.first(:conditions=>{:alt_model_id=>"123"})
+      assert_equal "hi there", activity.another_field
+    end
+    
+  end
+end