wonkavision 0.5.1 → 0.5.2

data/CHANGELOG.rdoc

@@ -1,3 +1,7 @@
+== 0.5.2
+* Added callbacks to event handler, before_event and after_event. Refactored event handling hierarchy to be a little
+  less functional and a little more object oriented.
+
 == 0.5.1
 * Ensure that subscriptions to an event namespace will only get notified once per incoming message
 

data/lib/wonkavision.rb

@@ -7,6 +7,7 @@ dir = File.dirname(__FILE__)
  "plugins",
  "event_path_segment",
  "event",
+ "event_context",
  "event_namespace",
  "event_coordinator",
  "event_binding",
@@ -14,6 +15,7 @@ dir = File.dirname(__FILE__)
  "message_mapper/indifferent_access",
  "message_mapper/map",
  "message_mapper",
+ "plugins/callbacks",
  "plugins/event_handling",
  "plugins/business_activity",
  "plugins/timeline",
@@ -43,7 +45,7 @@ module Wonkavision
 
     def namespace_wildcard_character
       @namespace_wildcard_character = "*"
-    end   
+    end
 
     def is_absolute_path(path)
       path.to_s[0..0] == event_path_separator
@@ -63,6 +65,9 @@ module Wonkavision
     end
   end
 
+  class WonkavisionError < StandardError #:nodoc:
+  end
+
 
 
 end

data/lib/wonkavision/event_context.rb

@@ -0,0 +1,9 @@
+module Wonkavision
+  class EventContext
+    attr_accessor :data, :path, :binding, :callback
+
+    def initialize(data,path,binding,callback)
+      @data, @path, @binding, @callback = data, path, binding, callback
+    end
+  end
+end

data/lib/wonkavision/event_handler.rb

@@ -6,6 +6,7 @@ module Wonkavision
       handler.class_eval do
         extend Plugins
         use Plugins::EventHandling
+        use Plugins::Callbacks
       end
 
       super

data/lib/wonkavision/plugins.rb

@@ -21,7 +21,7 @@ module Wonkavision
       include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
       extend mod::Fields           if mod.const_defined?(:Fields)
       include mod::Fields          if mod.const_defined?(:Fields)
-      mod.configure(self,options)          if mod.respond_to?(:configure)
+      mod.configure(self,options)  if mod.respond_to?(:configure)
       wonkavision_plugins << mod
     end
     alias use plug

data/lib/wonkavision/plugins/business_activity.rb

@@ -17,22 +17,26 @@ module Wonkavision
       end
 
       module ClassMethods
+        def instantiate_handler(event_context)
+          correlation_id = event_context.data[event_correlation_id_key.to_s]
+          find_activity_instance(correlation_id_field,correlation_id)
+        end
 
         def event(name,*args,&block)
-          handle(name,args) do |data,path|
-            activity = find_activity(data)
+          handle(name,args) do
+            ctx = @wonkavision_event_context
             result = :ok
             if (block_given?)
               result = case block.arity
-                         when 3 then yield activity,data,path
-                         when 2 then yield activity,data
-                         when 1 then yield activity
-                         else yield
+                         when 3 then yield ctx.data,ctx.path,self
+                         when 2 then yield ctx.data, ctx.path
+                         when 1 then yield ctx.data
+                         else instance_eval &block
                        end
             end
             unless result == :handled
-              result = update_activity(activity,data) unless result == :updated
-              activity.save!
+              result = self.class.update_activity(self,ctx.data) unless result == :updated
+              save!
             end
             result
           end
@@ -56,10 +60,7 @@ module Wonkavision
           correlation_ids << {:model=>model_field.to_s, :event=>event_field.to_s}
         end
 
-        def find_activity(event_data)
-          correlation_id = event_data[event_correlation_id_key.to_s]
-          find_activity_instance(correlation_id_field,correlation_id)
-        end
+
 
       end
 

data/lib/wonkavision/plugins/callbacks.rb

@@ -0,0 +1,182 @@
+# The note you see below, 'Almost all of this callback stuff...', along with all the code adapted from ActiveSupport,
+# is in turn adapted from MongoMapper, and for the same reasons.
+# encoding: UTF-8
+# Almost all of this callback stuff is pulled directly from ActiveSupport
+# in the interest of support rails 2 and 3 at the same time and is the
+# same copyright as rails.
+module Wonkavision
+  module Plugins
+    module Callbacks
+      def self.configure(handler,options)
+        handler.define_wonkavision_callbacks :before_event,
+                                 :after_event
+        
+        handler.alias_method_chain :handle_event, :callbacks
+      end
+
+      module ClassMethods
+        #The ODM library may already have taken care of mixing in callback functioanlity,
+        #in which case we'll just use that
+        def define_wonkavision_callbacks(*callbacks)
+          callbacks.each do |callback|
+            class_eval <<-"end_eval"
+              def self.#{callback}(*methods, &block)
+                callbacks = CallbackChain.build(:#{callback}, *methods, &block)
+                @#{callback}_callbacks ||= CallbackChain.new
+                @#{callback}_callbacks.concat callbacks
+              end
+
+              def self.#{callback}_callback_chain
+                @#{callback}_callbacks ||= CallbackChain.new
+
+                if superclass.respond_to?(:#{callback}_callback_chain)
+                  CallbackChain.new(
+                    superclass.#{callback}_callback_chain +
+                    @#{callback}_callbacks
+                  )
+                else
+                  @#{callback}_callbacks
+                end
+              end
+            end_eval
+          end
+        end
+      end
+
+      module InstanceMethods
+        def handle_event_with_callbacks
+          ctx = @wonkavision_event_context
+          run_wonkavision_callbacks(:before_event)
+          handle_event_without_callbacks
+          run_wonkavision_callbacks(:after_event)
+        end
+        
+        def run_wonkavision_callbacks(kind, options={}, &block)
+          callback_chain_method = "#{kind}_callback_chain"
+          return unless self.class.respond_to?(callback_chain_method)
+          self.class.send(callback_chain_method).run(self, options, &block)          
+        end
+      end
+
+      class CallbackChain < Array
+        def self.build(kind, *methods, &block)
+          methods, options = extract_options(*methods, &block)
+          methods.map! { |method| Callback.new(kind, method, options) }
+          new(methods)
+        end
+
+        def run(object, options={}, &terminator)
+          enumerator = options[:enumerator] || :each
+
+          unless block_given?
+            send(enumerator) { |callback| callback.call(object) }
+          else
+            send(enumerator) do |callback|
+              result = callback.call(object)
+              break result if terminator.call(result, object)
+            end
+          end
+        end
+
+        def replace_or_append!(chain)
+          if index = index(chain)
+            self[index] = chain
+          else
+            self << chain
+          end
+          self
+        end
+
+        def find(callback, &block)
+          select { |c| c == callback && (!block_given? || yield(c)) }.first
+        end
+
+        def delete(callback)
+          super(callback.is_a?(Callback) ? callback : find(callback))
+        end
+
+        private
+        def self.extract_options(*methods, &block)
+          methods.flatten!
+          options = methods.extract_options!
+          methods << block if block_given?
+          return methods, options
+        end
+
+        def extract_options(*methods, &block)
+          self.class.extract_options(*methods, &block)
+        end
+      end
+
+      class Callback
+        attr_reader :kind, :method, :identifier, :options
+
+        def initialize(kind, method, options={})
+          @kind       = kind
+          @method     = method
+          @identifier = options[:identifier]
+          @options    = options
+        end
+
+        def ==(other)
+          case other
+            when Callback
+              (self.identifier && self.identifier == other.identifier) || self.method == other.method
+            else
+              (self.identifier && self.identifier == other) || self.method == other
+          end
+        end
+
+        def eql?(other)
+          self == other
+        end
+
+        def dup
+          self.class.new(@kind, @method, @options.dup)
+        end
+
+        def hash
+          if @identifier
+            @identifier.hash
+          else
+            @method.hash
+          end
+        end
+
+        def call(*args, &block)
+          evaluate_method(method, *args, &block) if should_run_callback?(*args)
+        rescue LocalJumpError
+          raise ArgumentError,
+                "Cannot yield from a Proc type filter. The Proc must take two " +
+                        "arguments and execute #call on the second argument."
+        end
+
+        private
+        def evaluate_method(method, *args, &block)
+          case method
+            when Symbol
+              object = args.shift
+              object.send(method, *args, &block)
+            when String
+              eval(method, args.first.instance_eval { binding })
+            when Proc, Method
+              method.call(*args, &block)
+            else
+              if method.respond_to?(kind)
+                method.send(kind, *args, &block)
+              else
+                raise ArgumentError,
+                      "Callbacks must be a symbol denoting the method to call, a string to be evaluated, " +
+                              "a block to be invoked, or an object responding to the callback method."
+              end
+          end
+        end
+
+        def should_run_callback?(*args)
+          [options[:if]].flatten.compact.all? { |a| evaluate_method(a, *args) } &&
+                  ![options[:unless]].flatten.compact.any? { |a| evaluate_method(a, *args) }
+        end
+      end
+    end
+  end
+end

data/lib/wonkavision/plugins/event_handling.rb

@@ -11,6 +11,7 @@ module Wonkavision
 
         handler.write_inheritable_attribute :maps, []
         handler.class_inheritable_reader :maps
+
       end
 
       module ClassMethods
@@ -36,23 +37,53 @@ module Wonkavision
         def handle(name,*args,&block)
           binding = Wonkavision::EventBinding.new(name,self,*args)
           binding.subscribe_to_events do |event_data,event_path|
-            event_data = map_data(event_data,event_path)
-            if block_given?
-              case block.arity
-                when 2 then yield event_data,event_path
-                when 1 then yield event_data
-                else yield
-              end
-            end
+            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
+
+      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
         
-        private
+        def handle_event
+          ctx = @wonkavision_event_context
+          ctx.data = map(ctx.data,ctx.path)
+          handler = ctx.callback
 
-        def map_data(data,path)
-          maps.each do |map_def|
+          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)
@@ -61,18 +92,16 @@ module Wonkavision
         end
 
         def map?(condition,data,path)
-          return true unless condition && condition.to_s != 'all'
+          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
-          #default behavior
-          header.properties[:routing_key] == filter.to_s
         end
       end
-      #Code here
+
     end
   end
 end

data/lib/wonkavision/plugins/timeline.rb

@@ -27,20 +27,21 @@ module Wonkavision
       module ClassMethods
 
         def milestone(name,*args)
-          timeline_milestones << event(name,*args) do |activity,event_data,event_path|
-            event_time = extract_event_time(event_data,event_path)
-            prev_event_time = activity[timeline_field][name]
+          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
-              activity[timeline_field][name] = 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 = activity[latest_milestone_field]
+              latest_ms = self[latest_milestone_field]
               unless latest_ms &&
-                             (last_event = activity[timeline_field][latest_ms]) &&
+                             (last_event = self[timeline_field][latest_ms]) &&
                              last_event > event_time
-                update_activity(activity,event_data)
-                activity[latest_milestone_field] = name
+                self.class.update_activity(self,ctx.data)
+                self[latest_milestone_field] = name
               end
               :updated
             else
@@ -56,7 +57,6 @@ module Wonkavision
           time ? time.to_time : nil
         end
 
-        private
         def extract_event_time(event_data,event_path)
           convert_time(event_data.delete(event_time_key.to_s)) || Time.now.utc
         end

data/lib/wonkavision/version.rb

@@ -1,3 +1,3 @@
 module Wonkavision
-  VERSION = '0.5.1'
+  VERSION = '0.5.2'
 end

data/test/event_handler_test.rb

@@ -55,6 +55,15 @@ class EventHandlerTest < ActiveSupport::TestCase
       Wonkavision.event_coordinator.receive_event("vermicious/oompa",1);
       assert_equal 1, TestEventHandler.knids.length
     end
+
+    should "process any defined callbacks" do
+      TestEventHandler.reset
+
+      Wonkavision.event_coordinator.receive_event("vermicious/knid",1)
+      #3 execs of each kind of callback, one for event subscription, one for namespace sub and global sub
+      assert_equal 3 * 2, TestEventHandler.callbacks.length
+    end
+    
   end
 
 end