wonkavision 0.5.4 → 0.5.9

data/lib/wonkavision/persistence/mongoid_adapter.rb

@@ -0,0 +1,32 @@
+module Wonkavision
+  module Mongoid
+    module Activity
+
+      def self.included(model)
+        model.send(:include,::Mongoid::Document)
+        model.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        include Wonkavision::ActsAsOompaLoompa
+
+        def define_document_key(key_name,key_type,options={})
+          options[:type] = key_type
+          field(key_name,  options) unless fields[key_name]
+        end
+
+        def update_activity(activity,event_data)
+          activity.write_attributes(event_data)
+          :updated
+        end
+
+        def find_activity_instance(correlation_field_name,correlation_id)
+          self.find_or_create_by({correlation_field_name=>correlation_id})
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/wonkavision/plugins.rb

@@ -1,30 +1,30 @@
-#This concept (and code) shamelessly stolen from MongoMapper
-#(http://railstips.org/blog/archives/2010/02/21/mongomapper-07-plugins/)
-#as so much of my Ruby code tends to be.  I added a few little things and changed some
-#names to avoid conflicts.
-module Wonkavision
-  module Plugins
-    def wonkavision_plugins
-      @wonkavision_plugins ||= []
-    end
-
-    def has_wonkavision_plugin?(plugin)
-      wonkavision_plugins.detect{|p|p==plugin}
-    end
-
-    def ensure_wonkavision_plugin(plugin,option={})
-      use(plugin,options) unless has_wonkavision_plugin?(plugin)
-    end
-
-    def plug(mod,options={})
-      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
-      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)
-      wonkavision_plugins << mod
-    end
-    alias use plug
-    
-  end
-end
+#This concept (and code) shamelessly stolen from MongoMapper
+#(http://railstips.org/blog/archives/2010/02/21/mongomapper-07-plugins/)
+#as so much of my Ruby code tends to be.  I added a few little things and changed some
+#names to avoid conflicts.
+module Wonkavision
+  module Plugins
+    def wonkavision_plugins
+      @wonkavision_plugins ||= []
+    end
+
+    def has_wonkavision_plugin?(plugin)
+      wonkavision_plugins.detect{|p|p==plugin}
+    end
+
+    def ensure_wonkavision_plugin(plugin,option={})
+      use(plugin,options) unless has_wonkavision_plugin?(plugin)
+    end
+
+    def plug(mod,options={})
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      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)
+      wonkavision_plugins << mod
+    end
+    alias use plug
+    
+  end
+end

data/lib/wonkavision/plugins/business_activity.rb

@@ -1,93 +1,93 @@
-module Wonkavision
-  module Plugins
-    module BusinessActivity
-
-      def self.all
-        @@all ||= []
-      end
-
-
-      def self.configure(activity,options={})
-        activity.write_inheritable_attribute :business_activity_options, {}
-        activity.class_inheritable_reader :business_activity_options
-
-        activity.write_inheritable_attribute :correlation_ids, []
-        activity.class_inheritable_reader :correlation_ids
-
-        BusinessActivity.all << activity
-      end
-
-      def self.normalize_correlation_ids(*args)
-        model_field,event_field = if args.length == 1 then
-                                    case args[0]
-                                      when Hash then [args[0][:model], args[0][:event] || args[0][:model]]
-                                      else [args[0],args[0]]
-                                    end
-                                  else
-                                    [args[0],args[1] || args[0]]
-                                  end
-        {:model=>model_field,:event=>event_field}
-      end
-
-      module ClassMethods
-        def instantiate_handler(event_context)
-          correlation = event_context.binding.correlation
-          event_id = correlation ? (correlation[:event] || event_correlation_id_key) : event_correlation_id_key
-          model_id = correlation ? (correlation[:model] || correlation_id_field) : correlation_id_field
-
-          correlation_id = event_context.data[event_id.to_s]
-          find_activity_instance(model_id,correlation_id)
-        end
-
-        def event(name,*args,&block)
-          handle(name,args) do
-            ctx = @wonkavision_event_context
-            result = :ok
-            if (block_given?)
-              result = case block.arity
-                         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 = self.class.update_activity(self,ctx.data) unless result == :updated
-              save!
-            end
-            result
-          end
-        end
-
-        def correlate_by(*args)
-          return {:model=>correlation_id_field, :event=>event_correlation_id_key} if args.blank?
-
-          correlation = BusinessActivity.normalize_correlation_ids(*args)
-
-          business_activity_options[:correlation_id_field] = correlation[:model]
-          business_activity_options[:event_correlation_id_key] = correlation[:event]
-
-          define_document_key correlation_id_field, String, :index=>true
-          correlation_ids << correlation
-        end
-
-        def create_binding(name,handler,*args)
-          Wonkavision::Plugins::BusinessActivity::EventBinding.new(name,handler,*args)
-        end
-
-      end
-
-      module Fields
-
-        def correlation_id_field
-          business_activity_options[:correlation_id_field] ||= "id"
-        end
-
-        def event_correlation_id_key
-          business_activity_options[:event_correlation_id_key] || correlation_id_field
-        end
-
-      end
-    end
-  end
+module Wonkavision
+  module Plugins
+    module BusinessActivity
+
+      def self.all
+        @@all ||= []
+      end
+
+
+      def self.configure(activity,options={})
+        activity.write_inheritable_attribute :business_activity_options, {}
+        activity.class_inheritable_reader :business_activity_options
+
+        activity.write_inheritable_attribute :correlation_ids, []
+        activity.class_inheritable_reader :correlation_ids
+
+        BusinessActivity.all << activity
+      end
+
+      def self.normalize_correlation_ids(*args)
+        model_field,event_field = if args.length == 1 then
+                                    case args[0]
+                                      when Hash then [args[0][:model], args[0][:event] || args[0][:model]]
+                                      else [args[0],args[0]]
+                                    end
+                                  else
+                                    [args[0],args[1] || args[0]]
+                                  end
+        {:model=>model_field,:event=>event_field}
+      end
+
+      module ClassMethods
+        def instantiate_handler(event_context)
+          correlation = event_context.binding.correlation
+          event_id = correlation ? (correlation[:event] || event_correlation_id_key) : event_correlation_id_key
+          model_id = correlation ? (correlation[:model] || correlation_id_field) : correlation_id_field
+
+          correlation_id = event_context.data[event_id.to_s]
+          find_activity_instance(model_id,correlation_id)
+        end
+
+        def event(name,*args,&block)
+          handle(name,args) do
+            ctx = @wonkavision_event_context
+            result = :ok
+            if (block_given?)
+              result = case block.arity
+                         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 = self.class.update_activity(self,ctx.data) unless result == :updated
+              save!
+            end
+            result
+          end
+        end
+
+        def correlate_by(*args)
+          return {:model=>correlation_id_field, :event=>event_correlation_id_key} if args.blank?
+
+          correlation = BusinessActivity.normalize_correlation_ids(*args)
+
+          business_activity_options[:correlation_id_field] = correlation[:model]
+          business_activity_options[:event_correlation_id_key] = correlation[:event]
+
+          define_document_key correlation_id_field, String, :index=>true
+          correlation_ids << correlation
+        end
+
+        def create_binding(name,handler,*args)
+          Wonkavision::Plugins::BusinessActivity::EventBinding.new(name,handler,*args)
+        end
+
+      end
+
+      module Fields
+
+        def correlation_id_field
+          business_activity_options[:correlation_id_field] ||= "id"
+        end
+
+        def event_correlation_id_key
+          business_activity_options[:event_correlation_id_key] || correlation_id_field
+        end
+
+      end
+    end
+  end
 end

data/lib/wonkavision/plugins/business_activity/event_binding.rb

@@ -1,16 +1,16 @@
-module Wonkavision
-  module Plugins
-    module BusinessActivity
-      class EventBinding < Wonkavision::EventBinding
-        attr_reader :correlation
-        def initialize(*args)
-          super(*args)
-          if (correlation_args = @options.delete(:correlate_by))
-            correlation_args = [correlation_args] unless correlation_args.is_a?(Array)
-            @correlation = BusinessActivity.normalize_correlation_ids(*correlation_args)
-          end
-        end
-      end
-    end
-  end
+module Wonkavision
+  module Plugins
+    module BusinessActivity
+      class EventBinding < Wonkavision::EventBinding
+        attr_reader :correlation
+        def initialize(*args)
+          super(*args)
+          if (correlation_args = @options.delete(:correlate_by))
+            correlation_args = [correlation_args] unless correlation_args.is_a?(Array)
+            @correlation = BusinessActivity.normalize_correlation_ids(*correlation_args)
+          end
+        end
+      end
+    end
+  end
 end

data/lib/wonkavision/plugins/callbacks.rb

@@ -1,182 +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
+# 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