wonkavision 0.5.0

data/lib/wonkavision/message_mapper/indifferent_access.rb

@@ -0,0 +1,26 @@
+module Wonkavision
+  module MessageMapper
+    module IndifferentAccess
+      def [](key)
+        key = key.to_s
+        super(key)
+      end
+
+      def []=(key,val)
+        super(key.to_s,val)
+      end
+
+      def include?(key)
+        super(key.to_s)
+      end
+
+      def method_missing(sym,*args,&block)
+        return self[sym.to_s[0..-2]] = args[0] if sym.to_s =~ /.*=$/
+        return self[sym] if self.keys.include?(sym.to_s)
+        nil
+      end
+    end
+  end
+
+end
+

data/lib/wonkavision/message_mapper/map.rb

@@ -0,0 +1,126 @@
+module Wonkavision
+
+  module MessageMapper
+    class Map < Hash
+      include IndifferentAccess
+
+      def initialize(context)
+        @context_stack = []
+        @context_stack.push(context)
+      end
+
+
+
+      def context
+        @context_stack[-1]
+      end
+
+      def from (context,&block)
+        raise "No block ws provided to 'from'" unless block
+        @context_stack.push(context)
+        instance_eval(&block)
+        @context_stack.pop
+      end
+
+      def exec(map_name)
+        mapped = MessageMapper.execute(map_name,context)
+        self.merge!(mapped) if mapped
+      end
+      alias import exec
+
+      def map(source,options={},&block)
+        raise "Neither a block nor a map_name were provided to 'map'" unless (block || options.keys.include?(:map_name))
+        if (source.is_a?(Hash))
+          field_name = source.keys[0]
+          ctx = source[field_name]
+        else
+          field_name = source
+          ctx = context.instance_eval("self.#{field_name}")
+        end
+        if ctx
+          if (map_name = options.delete(:map_name))
+            child = MessageMapper.execute(map_name,ctx)
+          else
+            child = Map.new(ctx)
+            child.instance_eval(&block)
+          end
+        else
+          child = {}
+        end
+        self[field_name] = child
+      end
+
+      def string(*args)
+        value(*args) {to_s}
+      end
+
+      def float(*args)
+        value(*args){respond_to?(:to_f) ? to_f : self}
+      end
+
+      def iso8601(*args)
+        value(*args) do
+          if respond_to?(:strftime)
+            strftime("%Y-%m-%dT%H:%M:%S")
+          elsif respond_to?(:ToString)
+            ToString("yyyy-MM-ddTHH:mm:ss")
+          else
+            self
+          end
+        end
+      end
+
+      def date(*args)
+        value(*args) do
+          if kind_of?(Time) || kind_of?(Date)
+            self
+          elsif respond_to?(:to_time)
+            to_time
+          elsif respond_to?(:to_date)
+            to_date
+          elsif (date_str=to_s) && date_str.length > 0
+            begin
+              Time.parse(date_str)
+            rescue
+              self
+            end
+          else
+            self
+          end
+        end
+      end
+
+      def boolean(*args)
+        value(*args) do
+          %w(true yes).include?(to_s.downcase) ? true : false
+        end
+      end
+
+      def int(*args)
+        value(*args){respond_to?(:to_i) ? to_i : self}
+      end
+
+      def value(*args,&block)
+        if (args.length == 1 && args[0].is_a?(Hash))
+          args[0].each do |key,value|
+            value = context.instance_eval(&value) if value.is_a?(Proc)
+            value = value.instance_eval(&block) if block
+            self[key] = value
+          end
+        else
+          args.each do |field_name|
+            if context.respond_to?(field_name.to_sym)
+              value = context.instance_eval("self.#{field_name}")
+            elsif context.respond_to?(:[])
+              value = context[field_name]
+            else
+              value = nil
+            end
+            value = value.instance_eval(&block) if block
+            self[field_name] = value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wonkavision/persistence/mongo_mapper_adapter.rb

@@ -0,0 +1,33 @@
+module Wonkavision
+  module Persistence
+    module MongoMapperAdapter
+
+      def self.included(model)
+        model.plugin Wonkavision::Persistence::MongoMapperAdapter
+      end
+
+      module ClassMethods
+        include Wonkavision::ActsAsOompaLoompa        
+
+        def define_document_key(key_name,key_type,options={})
+          key(key_name, key_type, options) unless keys[key_name]
+        end
+
+        def update_activity(activity,event_data)
+          activity.assign(event_data)
+          :updated
+        end
+
+        def find_activity_instance(correlation_field_name,correlation_id)
+          self.send("find_or_create_by_#{correlation_field_name}",correlation_id)
+        end
+      end
+
+    end
+
+  end
+end
+
+if defined?(::MongoMapper::Document)
+  MongoMapper::Document.append_inclusions(Wonkavision::Persistence::MongoMapperAdapter)
+end

data/lib/wonkavision/plugins.rb

@@ -0,0 +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

data/lib/wonkavision/plugins/business_activity.rb

@@ -0,0 +1,79 @@
+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
+
+      module ClassMethods
+
+        def event(name,*args,&block)
+          handle(name,args) do |data,path|
+            activity = find_activity(data)
+            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
+                       end
+            end
+            unless result == :handled
+              result = update_activity(activity,data) unless result == :updated
+              activity.save!
+            end
+            result
+          end
+        end
+
+        def correlate_by(*args)
+          return {:model=>correlation_id_field, :event=>event_correlation_id_key} if args.blank?
+          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
+
+          business_activity_options[:correlation_id_field] = model_field
+          business_activity_options[:event_correlation_id_key] = event_field
+
+          define_document_key correlation_id_field, String, :index=>true
+          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
+
+      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/event_handling.rb

@@ -0,0 +1,78 @@
+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 = 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
+          end
+          bindings << binding
+          binding
+        end
+        
+        private
+
+        def map_data(data,path)
+          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'
+          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

@@ -0,0 +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 |activity,event_data,event_path|
+            event_time = extract_event_time(event_data,event_path)
+            prev_event_time = activity[timeline_field][name]
+            unless prev_event_time
+              activity[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]
+              unless latest_ms &&
+                             (last_event = activity[timeline_field][latest_ms]) &&
+                             last_event > event_time
+                update_activity(activity,event_data)
+                activity[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
+
+        private
+        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