wonkavision 0.5.0

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+
+== 0.5.0
+* Initial release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2010 Nathan Stults
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  require File.dirname(__FILE__) + "/lib/wonkavision/version"
+
+  Jeweler::Tasks.new do |s|
+    s.name = "wonkavision"
+    s.version = Wonkavision::VERSION
+    s.summary = "Simple Business Activity Monitoring"
+    s.description = "Wonkavision is a small gem that allows you to publish"
+    s.email = "hereiam@sonic.net"
+    s.homepage = "http://github.com/PlasticLizard/wonkavision"
+    s.authors = ["Nathan Stults"]
+    s.has_rdoc = false #=>Should be true, someday
+    s.extra_rdoc_files = ["README.rdoc", "LICENSE.txt"]
+    s.files = FileList["[A-Z]*", "{bin,lib,test}/**/*"]
+
+    s.add_dependency('activesupport', '>= 2.3')
+
+    s.add_development_dependency('shoulda', '2.10.3')
+  end
+
+  Jeweler::GemcutterTasks.new
+
+rescue LoadError => ex
+  puts "Jeweler not available. Install it for jeweler-related tasks with: sudo gem install jeweler"
+
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'libs' << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'test'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :test

data/lib/wonkavision.rb

@@ -0,0 +1,68 @@
+require "rubygems"
+require "active_support"
+require "active_support/hash_with_indifferent_access" unless defined?(HashWithIndifferentAccess)
+
+dir = File.dirname(__FILE__)
+["support",
+ "plugins",
+ "event_path_segment",
+ "event",
+ "event_namespace",
+ "event_coordinator",
+ "event_binding",
+ "event_handler",
+ "message_mapper/indifferent_access",
+ "message_mapper/map",
+ "message_mapper",
+ "plugins/event_handling",
+ "plugins/business_activity",
+ "plugins/timeline",
+ "acts_as_oompa_loompa",
+ "persistence/mongo_mapper_adapter"].each {|lib|require File.join(dir,'wonkavision',lib)}
+
+#require File.join(dir,"cubicle","mongo_mapper","aggregate_plugin") if defined?(MongoMapper::Document)
+
+module Wonkavision
+
+#  def self.register_cubicle_directory(directory_path, recursive=true)
+#    searcher = "#{recursive ? "*" : "**/*"}.rb"
+#    Dir[File.join(directory_path,searcher)].each {|cubicle| require cubicle}
+#  end
+
+  class << self
+
+    attr_accessor :event_path_separator
+
+    def event_coordinator
+      @event_coordinator ||= Wonkavision::EventCoordinator.new
+    end
+
+    def event_path_separator
+      @event_path_separator ||= '/'
+    end
+
+    def namespace_wildcard_character
+      @namespace_wildcard_character = "*"
+    end   
+
+    def is_absolute_path(path)
+      path.to_s[0..0] == event_path_separator
+    end
+
+    def normalize_event_path(event_path)
+      event_path.to_s.split(event_path_separator).map{|s|s.underscore}.join(event_path_separator)
+    end
+
+    def join (*args)
+      args.map!{|segment|normalize_event_path(segment)}
+      args.reject{|segment|segment.blank?}.join(event_path_separator)
+    end
+
+    def split(event_path)
+      event_path.split(event_path_separator)
+    end
+  end
+
+
+
+end

data/lib/wonkavision/acts_as_oompa_loompa.rb

@@ -0,0 +1,22 @@
+module Wonkavision
+  module ActsAsOompaLoompa
+
+    def acts_as_event_handler
+      include Wonkavision::EventHandler
+    end
+
+    def acts_as_business_activity(opts={})
+      acts_as_event_handler
+      use Wonkavision::Plugins::BusinessActivity, opts
+    end
+
+    def acts_as_timeline(opts={})
+      acts_as_business_activity(opts)
+      use Wonkavision::Plugins::Timeline, opts
+    end
+
+    def acts_like_a_child(opts={})
+      raise "I don't want to include any plugins!" if (1 + rand(10)) % 3 == 0
+    end
+  end
+end

data/lib/wonkavision/event.rb

@@ -0,0 +1,33 @@
+module Wonkavision
+
+  class Event < Wonkavision::EventPathSegment
+
+    def initialize(name, namespace, opts={})
+      super name,namespace,opts
+      @source_events = []
+      source_events(*opts.delete(:source_events)) if opts.keys.include?(:source_events)
+    end
+
+    def matches(event_path)
+      event_path == path || @source_events.detect{|evt|evt.matches(event_path)} != nil
+    end
+
+    def notify_subscribers(event_data,event_path)
+      super(event_data,self.path)
+    end
+
+    def source_events(*args)
+      return @source_events if args.blank?
+      @source_events = @source_events.concat(args.map do |source|
+         source_ns = namespace
+         if (source=~/^\/.*/)
+           source_ns = root_namespace
+           source = source[1..-1]
+         end
+         source_ns.find_or_create(source)
+      end)
+    end
+  end
+
+end
+  

data/lib/wonkavision/event_binding.rb

@@ -0,0 +1,21 @@
+module Wonkavision
+
+  class EventBinding
+    attr_reader :name, :events, :options
+
+    def initialize(name,handler,*args)
+      @options = args.extract_options!
+      @handler = handler
+      @name = name
+      @events = []
+      args = [@name] if args.blank? || args.flatten.blank?
+      @events = args.flatten.map{|evt_name|@handler.event_path(evt_name)}
+    end
+
+    def subscribe_to_events(&block)
+      @events.each do |event|
+        Wonkavision.event_coordinator.subscribe(event,&block)
+      end
+    end
+  end
+end

data/lib/wonkavision/event_coordinator.rb

@@ -0,0 +1,75 @@
+module Wonkavision
+  class EventCoordinator
+
+    attr_reader :root_namespace
+
+    def initialize
+      @root_namespace = Wonkavision::EventNamespace.new
+      @lock = Mutex.new
+      #@event_cache = {}
+      @incoming_event_filters = []
+    end
+
+    def before_receive_event(&block)
+      @incoming_event_filters << block
+    end
+
+    def clear_filters
+      @incoming_event_filters = []
+    end
+
+    def configure(&block)
+      self.instance_eval(&block)
+    end
+
+    def map ()
+      yield root_namespace if block_given?
+    end
+
+    def subscribe(event_path,final_segment_type=nil,&block)
+      event_path, final_segment_type = *detect_final_segment(event_path) unless final_segment_type
+      segment = (event_path.blank? ? root_namespace : root_namespace.find_or_create(event_path,final_segment_type))
+      segment.subscribe(&block)
+    end
+
+    def receive_event(event_path, event_data)
+      @lock.synchronize do
+                          #If process_incoming_event returns nil or false, it means a filter chose to abort
+                          #the event processing, in which case we'll break for lunch.
+        return unless event_data = process_incoming_event(event_path,event_data)
+
+        event_path = Wonkavision.normalize_event_path(event_path)
+        targets = root_namespace.find_matching_events(event_path)
+        #If the event wasn't matched, maybe someone is subscribing to '/*' ? 
+        targets = [root_namespace] if targets.blank?
+        targets.each{|target|target.notify_subscribers(event_data,event_path)}
+      end
+    end
+
+    protected
+    def process_incoming_event(event_path,event_data)
+      return nil unless event_data
+      @incoming_event_filters.each do |filter_block|
+        if (filter_block.arity < 1)
+          event_data = event_data.instance_eval(&filter_block)
+        elsif filter_block.arity == 1
+          event_data = filter_block.call(event_data)
+        else
+          event_data = filter_block.call(event_data,event_path)
+        end
+        return nil unless event_data
+      end
+      event_data
+    end
+
+    def detect_final_segment(event_path)
+      parts = Wonkavision.split(event_path)
+      if parts[-1] == Wonkavision.namespace_wildcard_character
+        [Wonkavision.join(parts.slice(0..-2)),:namespace]
+      else
+        [event_path,:event]
+      end
+    end
+
+  end
+end

data/lib/wonkavision/event_handler.rb

@@ -0,0 +1,14 @@
+module Wonkavision
+
+  module EventHandler
+
+    def self.included(handler)
+      handler.class_eval do
+        extend Plugins
+        use Plugins::EventHandling
+      end
+
+      super
+    end
+  end
+end

data/lib/wonkavision/event_namespace.rb

@@ -0,0 +1,72 @@
+module Wonkavision
+
+  class EventNamespace < EventPathSegment
+
+    attr_reader :children
+
+    def initialize(name=nil,namespace = nil,opts={})
+      super name, namespace,opts
+      @children=HashWithIndifferentAccess.new
+    end
+
+    def find_or_create (path, final_segment_type = :event)
+      if path.is_a?(Array)
+        child_name = path.shift
+        segment_type = path.blank? ? final_segment_type : :namespace
+        child = @children[child_name] ||=  self.send(segment_type,child_name)
+        return child if path.blank?
+        raise "Events cannot have children. The path  you requested is not valid" if child.is_a?(Wonkavision::Event)
+        child.find_or_create(path,final_segment_type)
+      else
+        path = Wonkavision.normalize_event_path(path)
+        source_ns = self
+        if (Wonkavision.is_absolute_path(path)) #indicates an absolute path, because it begins with a '/'
+          source_ns = root_namespace
+          path = path[1..-1]
+        end
+        source_ns.find_or_create(path.split(Wonkavision.event_path_separator), final_segment_type)
+      end
+    end
+
+    def find_matching_events (event_path)
+      events = []
+      @children.each_value do |child|
+        if (child.is_a?(Wonkavision::Event))
+          events << child if child.matches(event_path)
+        elsif (child.is_a?(Wonkavision::EventNamespace))
+          events.concat(child.find_matching_events(event_path))
+        else
+          raise "An unexpected child type was encountered in find_matching_events #{child.class}"
+        end
+      end
+      #If no child was found, and the event matches this namespace, we should add ourselves to the list.
+      #This is not necessary if any child event was located, because in that case event notifications
+      #would bubble up to us anyway. If no event was found, there's nobody to blow the bubble but us.
+      events << self if events.blank? && matches_event(event_path)
+      events
+    end
+
+    def matches_event(event_path)
+      Wonkavision.split(path) == Wonkavision.split(event_path).slice(0..-2)
+    end
+
+    #dsl
+    def namespace(*args)
+      return super if args.blank?
+      name, opts = args.shift, (args.shift || {})
+      ns = Wonkavision::EventNamespace.new(name,self,opts)
+      yield ns if block_given?
+      @children[ns.name] = ns
+      ns
+    end
+
+    def event(*args)
+      name, opts  = args.shift, args.extract_options!
+      opts[:source_events] = (opts[:source_events] || []).concat(args) unless args.blank?
+      evt = Wonkavision::Event.new(name,self,opts)
+      yield evt if block_given?
+      @children[evt.name] = evt
+      evt
+    end
+  end
+end

data/lib/wonkavision/event_path_segment.rb

@@ -0,0 +1,37 @@
+module Wonkavision
+  class EventPathSegment
+    attr_reader :name, :namespace, :options, :subscribers
+
+    def initialize(name = nil, namespace = nil, opts={})
+      @name = name
+      @namespace = namespace
+      @options = opts
+      @subscribers = []
+    end
+
+    def path
+      Wonkavision.join(namespace.blank? ? nil : namespace.path,name)
+    end
+    
+    def subscribe(&block)
+      @subscribers << block
+      self
+    end   
+
+    def notify_subscribers(event_data, event_path=self.path)
+      @subscribers.each do |sub|
+        sub.call(event_data,event_path)
+      end
+      namespace.notify_subscribers(event_data,event_path) if namespace
+    end
+
+    def root_namespace
+      cur_namespace = self
+      while (cur_namespace.namespace)
+        cur_namespace=cur_namespace.namespace
+      end
+      cur_namespace
+    end
+
+  end
+end

data/lib/wonkavision/message_mapper.rb

@@ -0,0 +1,30 @@
+module Wonkavision
+
+  module MessageMapper
+
+    class << self
+      def maps
+        @maps ||={}
+      end
+
+      def register(map_name,&block)
+        MessageMapper.maps[map_name] = block
+      end
+
+      def execute(map,data_source)
+        map_block = map.kind_of?(Proc) ? map : MessageMapper.maps[map]
+
+        raise "#{map} not found" unless map_block
+        message = MessageMapper::Map.new(data_source)
+        message.instance_eval(&map_block)
+        message
+      end
+
+      def register_map_directory(directory_path, recursive=true)
+        searcher = "#{recursive ? "*" : "**/*"}.rb"
+        Dir[File.join(directory_path,searcher)].each {|map| require map}
+      end
+    end
+
+  end
+end