wonkavision 0.5.4 → 0.5.9

data/lib/wonkavision/event_coordinator.rb

@@ -1,75 +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_segments(event_path).values
-        #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
+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_segments(event_path).values
+        #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

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

data/lib/wonkavision/event_namespace.rb

@@ -1,79 +1,79 @@
-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_segments (event_path)
-      selected = {}
-      @children.each_value do |child|
-        if (child.is_a?(Wonkavision::Event))
-          select_segment(child,selected) if child.matches(event_path)
-        elsif (child.is_a?(Wonkavision::EventNamespace))
-          selected.merge!(child.find_matching_segments(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.
-      select_segment(self,selected) if selected.blank? && matches_event(event_path)
-      selected
-    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 = @children[name] || 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 = @children[name] || Wonkavision::Event.new(name,self,opts)
-      yield evt if block_given?
-      @children[evt.name] = evt
-      evt
-    end
-
-    private
-    def select_segment(segment,selected)
-      selected[segment.name] = segment
-      select_segment(segment.namespace,selected) if segment.namespace
-    end
-
-  end
-end
+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_segments (event_path)
+      selected = {}
+      @children.each_value do |child|
+        if (child.is_a?(Wonkavision::Event))
+          select_segment(child,selected) if child.matches(event_path)
+        elsif (child.is_a?(Wonkavision::EventNamespace))
+          selected.merge!(child.find_matching_segments(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.
+      select_segment(self,selected) if selected.blank? && matches_event(event_path)
+      selected
+    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 = @children[name] || 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 = @children[name] || Wonkavision::Event.new(name,self,opts)
+      yield evt if block_given?
+      @children[evt.name] = evt
+      evt
+    end
+
+    private
+    def select_segment(segment,selected)
+      selected[segment.name] = segment
+      select_segment(segment.namespace,selected) if segment.namespace
+    end
+
+  end
+end

data/lib/wonkavision/event_path_segment.rb

@@ -1,36 +1,36 @@
-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
-    end
-
-    def root_namespace
-      cur_namespace = self
-      while (cur_namespace.namespace)
-        cur_namespace=cur_namespace.namespace
-      end
-      cur_namespace
-    end
-
-  end
+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
+    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

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