wonkavision 0.5.0 → 0.5.1

data/CHANGELOG.rdoc

@@ -1,3 +1,5 @@
+== 0.5.1
+* Ensure that subscriptions to an event namespace will only get notified once per incoming message
 
 == 0.5.0
 * Initial release

data/lib/wonkavision/event.rb

@@ -1,33 +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
+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_coordinator.rb

@@ -39,7 +39,7 @@ module Wonkavision
         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)
+        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)}

data/lib/wonkavision/event_namespace.rb

@@ -28,13 +28,13 @@ module Wonkavision
       end
     end
 
-    def find_matching_events (event_path)
-      events = []
+    def find_matching_segments (event_path)
+      selected = {}
       @children.each_value do |child|
         if (child.is_a?(Wonkavision::Event))
-          events << child if child.matches(event_path)
+          select_segment(child,selected) if child.matches(event_path)
         elsif (child.is_a?(Wonkavision::EventNamespace))
-          events.concat(child.find_matching_events(event_path))
+          selected.merge!(child.find_matching_segments(event_path))
         else
           raise "An unexpected child type was encountered in find_matching_events #{child.class}"
         end
@@ -42,8 +42,8 @@ module Wonkavision
       #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
+      select_segment(self,selected) if selected.blank? && matches_event(event_path)
+      selected
     end
 
     def matches_event(event_path)
@@ -54,7 +54,7 @@ module Wonkavision
     def namespace(*args)
       return super if args.blank?
       name, opts = args.shift, (args.shift || {})
-      ns = Wonkavision::EventNamespace.new(name,self,opts)
+      ns = @children[name] || Wonkavision::EventNamespace.new(name,self,opts)
       yield ns if block_given?
       @children[ns.name] = ns
       ns
@@ -63,10 +63,17 @@ module Wonkavision
     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)
+      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

@@ -22,7 +22,6 @@ module Wonkavision
       @subscribers.each do |sub|
         sub.call(event_data,event_path)
       end
-      namespace.notify_subscribers(event_data,event_path) if namespace
     end
 
     def root_namespace

data/lib/wonkavision/version.rb

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

data/test/event_handler_test.rb

@@ -23,8 +23,8 @@ class EventHandlerTest < ActiveSupport::TestCase
     should "handle subscriptions to the configured namespace" do
       TestEventHandler.reset
       Wonkavision.event_coordinator.receive_event("vermicious/hose",1)
-      Wonkavision.event_coordinator.receive_event("vermicious/kid",2)
-      Wonkavision.event_coordinator.receive_event("vermiciouser/kid",3)
+      Wonkavision.event_coordinator.receive_event("vermicious/dog",2)
+      Wonkavision.event_coordinator.receive_event("vermiciouser/knid",3)
       puts TestEventHandler.knids.inspect
       assert_equal 2, TestEventHandler.knids.length
       assert_equal 1, TestEventHandler.knids[0][0]
@@ -42,6 +42,19 @@ class EventHandlerTest < ActiveSupport::TestCase
       assert_equal 3, TestEventHandler.knids[2][0]
 
     end
+
+    should "only notify once per namespace, even if multiple events are matched in a given namespace" do
+      TestEventHandler.reset
+
+      Wonkavision.event_coordinator.map do |events|
+        events.namespace :vermicious do |v|
+          v.event :composite, 'oompa','loompa'
+        end
+      end
+
+      Wonkavision.event_coordinator.receive_event("vermicious/oompa",1);
+      assert_equal 1, TestEventHandler.knids.length
+    end
   end
 
 end

data/test/event_namespace_test.rb

@@ -1,109 +1,109 @@
-require "test_helper"
-
-class EventNamespaceTest < ActiveSupport::TestCase
-
-  context "EventNamespace#namespace" do
-    should "return the namespace if no arguments are provided" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = Wonkavision::EventNamespace.new :ns2, ns1
-      assert_equal ns1, ns2.namespace
-    end
-    should "create a new namespace with the provided name" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = ns1.namespace :ns2
-      assert_equal ns1, ns2.namespace
-      assert_equal ns2, ns1.children[ns2.name] 
-    end
-    should "yield the new namespace for modification" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = ns1.namespace(:ns2){|child|child.namespace(:ns3)}
-      assert_equal 1, ns2.children.length
-      assert_equal "ns3", ns2.children.keys[0]
-    end
-  end
-
-  context "EventNamespace#event" do
-    should "create a new event with the provided name" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.event :evt1
-      assert_equal ns1, evt.namespace
-      assert_equal evt, ns1.children[evt.name]
-    end
-    should "provide source_events to the new event if in the opts hash" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.event :evt1, :source_events=>"evt2"
-      assert_equal "evt2", evt.source_events[0].name
-    end
-     should "yield new event to block if provided" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.event(:evt1) {|evt|evt.source_events "evt2"}
-      assert_equal "evt2", evt.source_events[0].name
-    end
-  end
-
-  context "EventNamespace#find_or_create" do
-    should "find an existing direct child event" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.event :evt1
-      assert_equal evt, ns1.find_or_create("evt1")
-    end
-    should "find a nested event" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.namespace(:ns2).event(:evt1)
-      assert_equal evt, ns1.find_or_create("ns2/evt1")
-    end
-    should "find a direct child namespace" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = ns1.namespace :ns2
-      assert_equal ns2, ns1.find_or_create("ns2")
-    end
-    should "find a nested namespace" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns3 = ns1.namespace(:ns2).namespace(:ns3)
-      assert_equal ns3, ns1.find_or_create("ns2/ns3")
-    end
-    should "create a top level child event if not found" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.find_or_create("TheNewEvent")
-      assert_equal "ns1/the_new_event", evt.path
-    end
-    should "create a top level child namespace if not found" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = ns1.find_or_create("TheNewNamespace",:namespace)
-      assert_equal "ns1/the_new_namespace",ns2.path
-    end
-    should "create a nested event if namespace exits but event not found" do
-      ns1 = Wonkavision::EventNamespace.new(:ns1)
-      ns1.namespace :ns2
-      evt = ns1.find_or_create("ns2/new_event")
-      assert_equal "ns1/ns2/new_event",evt.path
-    end
-    should "create a nested namespace and event if not found" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      evt = ns1.find_or_create("ns3/new_event")
-      assert_equal "ns1/ns3/new_event",evt.path
-      assert ns1.children["ns3"].children["new_event"]
-    end
-    should "create nested namespaces if not found" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns3 = ns1.find_or_create "not/found/my/friend",:namespace
-      assert ns3.is_a?(Wonkavision::EventNamespace)
-      assert_equal "ns1/not/found/my/friend", ns3.path
-    end
-  end
-  context "EventNamespace#find_matching_values" do
-    should "find all events matching the specified path" do
-      ns1 = Wonkavision::EventNamespace.new :ns1
-      ns2 = ns1.namespace :ns2
-      ns2.event "my_event"
-      ns2.event :e1, "my_event"
-      ns3 = ns2.namespace :ns3
-      ns3.event :e2, "/ns2/my_event"
-      ns4 = ns1.namespace :ns4
-      ns4.event :e3, "/ns2/my_event"
-      ns4.event "my_event"
-
-      assert_equal 4, ns1.find_matching_events("ns1/ns2/my_event").length
-    end
-  end
+require "test_helper"
+
+class EventNamespaceTest < ActiveSupport::TestCase
+
+  context "EventNamespace#namespace" do
+    should "return the namespace if no arguments are provided" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = Wonkavision::EventNamespace.new :ns2, ns1
+      assert_equal ns1, ns2.namespace
+    end
+    should "create a new namespace with the provided name" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = ns1.namespace :ns2
+      assert_equal ns1, ns2.namespace
+      assert_equal ns2, ns1.children[ns2.name] 
+    end
+    should "yield the new namespace for modification" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = ns1.namespace(:ns2){|child|child.namespace(:ns3)}
+      assert_equal 1, ns2.children.length
+      assert_equal "ns3", ns2.children.keys[0]
+    end
+  end
+
+  context "EventNamespace#event" do
+    should "create a new event with the provided name" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.event :evt1
+      assert_equal ns1, evt.namespace
+      assert_equal evt, ns1.children[evt.name]
+    end
+    should "provide source_events to the new event if in the opts hash" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.event :evt1, :source_events=>"evt2"
+      assert_equal "evt2", evt.source_events[0].name
+    end
+     should "yield new event to block if provided" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.event(:evt1) {|evt|evt.source_events "evt2"}
+      assert_equal "evt2", evt.source_events[0].name
+    end
+  end
+
+  context "EventNamespace#find_or_create" do
+    should "find an existing direct child event" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.event :evt1
+      assert_equal evt, ns1.find_or_create("evt1")
+    end
+    should "find a nested event" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.namespace(:ns2).event(:evt1)
+      assert_equal evt, ns1.find_or_create("ns2/evt1")
+    end
+    should "find a direct child namespace" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = ns1.namespace :ns2
+      assert_equal ns2, ns1.find_or_create("ns2")
+    end
+    should "find a nested namespace" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns3 = ns1.namespace(:ns2).namespace(:ns3)
+      assert_equal ns3, ns1.find_or_create("ns2/ns3")
+    end
+    should "create a top level child event if not found" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.find_or_create("TheNewEvent")
+      assert_equal "ns1/the_new_event", evt.path
+    end
+    should "create a top level child namespace if not found" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = ns1.find_or_create("TheNewNamespace",:namespace)
+      assert_equal "ns1/the_new_namespace",ns2.path
+    end
+    should "create a nested event if namespace exits but event not found" do
+      ns1 = Wonkavision::EventNamespace.new(:ns1)
+      ns1.namespace :ns2
+      evt = ns1.find_or_create("ns2/new_event")
+      assert_equal "ns1/ns2/new_event",evt.path
+    end
+    should "create a nested namespace and event if not found" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      evt = ns1.find_or_create("ns3/new_event")
+      assert_equal "ns1/ns3/new_event",evt.path
+      assert ns1.children["ns3"].children["new_event"]
+    end
+    should "create nested namespaces if not found" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns3 = ns1.find_or_create "not/found/my/friend",:namespace
+      assert ns3.is_a?(Wonkavision::EventNamespace)
+      assert_equal "ns1/not/found/my/friend", ns3.path
+    end
+  end
+  context "EventNamespace#find_matching_values" do
+    should "find all events matching the specified path" do
+      ns1 = Wonkavision::EventNamespace.new :ns1
+      ns2 = ns1.namespace :ns2
+      ns2.event "my_event"
+      ns2.event :e1, "my_event"
+      ns3 = ns2.namespace :ns3
+      ns3.event :e2, "/ns2/my_event"
+      ns4 = ns1.namespace :ns4
+      ns4.event :e3, "/ns2/my_event"
+      ns4.event "my_event"
+
+      assert_equal 8, ns1.find_matching_segments("ns1/ns2/my_event").length
+    end
+  end
 end

data/test/event_path_segment_test.rb

@@ -1,56 +1,42 @@
-require "test_helper"
-
-class EventPathSegmentTest < ActiveSupport::TestCase
-  context "EventPathSegment#path" do
-    should  "not include path segments for root segments" do
-      assert_equal "a_segment", Wonkavision::EventPathSegment.new(:a_segment).path
-    end
-    should "join the parent namespace in the path for non root segments" do
-      ns1 = Wonkavision::EventPathSegment.new(:ns_1)
-      ns2 = Wonkavision::EventPathSegment.new(:ns_2, ns1)
-      assert_equal "ns_1/ns_2/a_segment", Wonkavision::EventPathSegment.new(:a_segment,ns2).path
-    end
-    should "ignore segments in a hierarchy with a nil name" do
-      ns1 = Wonkavision::EventPathSegment.new(:ns_1)
-      ns2 = Wonkavision::EventPathSegment.new(nil,ns1)
-      assert_equal "ns_1/a_segment", Wonkavision::EventPathSegment.new(:a_segment,ns2).path
-    end
-  end
-
-  context "EventPathSegment#subscribe" do
-    should "Add the provided block to the list of subscribers" do
-      seg = Wonkavision::EventPathSegment.new
-      x = 1
-      seg.subscribe {x+=1 }
-      assert_equal 1, seg.subscribers.length
-      seg.subscribers[0].call
-      assert_equal 2, x
-    end
-  end
-
-  context "EventPathSegment#notifiy_subscribers" do
-    should "call each subscribed block" do
-      seg = Wonkavision::EventPathSegment.new
-      x = 1
-      seg.subscribe {x+=1}
-      seg.subscribe {|data,path|x+=data+path}
-      seg.notify_subscribers(5,2)
-
-      assert_equal 9, x
-    end
-    should "bubble the call to notify_subscribers up the hierarchy" do
-      called = []
-      ns1 = Wonkavision::EventPathSegment.new(:ns1)
-      ns1.subscribe {called << ns1}
-      ns2 = Wonkavision::EventPathSegment.new(:ns2,ns1)
-      ns2.subscribe {called << ns2}
-      evt = Wonkavision::EventPathSegment.new(:evt,ns2)
-
-      evt.notify_subscribers(nil)
-
-      assert_equal 2, called.length
-      assert_equal ns2, called[0]
-      assert_equal ns1, called[1]
-    end
-  end
+require "test_helper"
+
+class EventPathSegmentTest < ActiveSupport::TestCase
+  context "EventPathSegment#path" do
+    should  "not include path segments for root segments" do
+      assert_equal "a_segment", Wonkavision::EventPathSegment.new(:a_segment).path
+    end
+    should "join the parent namespace in the path for non root segments" do
+      ns1 = Wonkavision::EventPathSegment.new(:ns_1)
+      ns2 = Wonkavision::EventPathSegment.new(:ns_2, ns1)
+      assert_equal "ns_1/ns_2/a_segment", Wonkavision::EventPathSegment.new(:a_segment,ns2).path
+    end
+    should "ignore segments in a hierarchy with a nil name" do
+      ns1 = Wonkavision::EventPathSegment.new(:ns_1)
+      ns2 = Wonkavision::EventPathSegment.new(nil,ns1)
+      assert_equal "ns_1/a_segment", Wonkavision::EventPathSegment.new(:a_segment,ns2).path
+    end
+  end
+
+  context "EventPathSegment#subscribe" do
+    should "Add the provided block to the list of subscribers" do
+      seg = Wonkavision::EventPathSegment.new
+      x = 1
+      seg.subscribe {x+=1 }
+      assert_equal 1, seg.subscribers.length
+      seg.subscribers[0].call
+      assert_equal 2, x
+    end
+  end
+
+  context "EventPathSegment#notifiy_subscribers" do
+    should "call each subscribed block" do
+      seg = Wonkavision::EventPathSegment.new
+      x = 1
+      seg.subscribe {x+=1}
+      seg.subscribe {|data,path|x+=data+path}
+      seg.notify_subscribers(5,2)
+
+      assert_equal 9, x
+    end    
+  end
 end