event_aggregator 1.1.4 → 1.1.5

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MTA4MzQ1NDU2ZDMxMzkzYTQ0ZjkwNzBlMGFlODhhMDE2NWZjYjU5Yw==
+    ZmEwZGVmNTFlNWM4ZDQ2YjM4MzRiMWU1OWEzNTA2NjEwYjFhMTdhYg==
   data.tar.gz: !binary |-
-    OWIwZmY0NGM0NzBmOGU2MDc2ZGYxMDBkZjY5NjlmNjVmOWJjMjM0Ng==
+    ZTc3MDBjMTQ0MzJhMGIxMjllYjBmYTkxMDlhMTg3NmJhYTNmNTNhNA==
 SHA512:
   metadata.gz: !binary |-
-    YWI2ZjJhOTAzMTU3MTNmNzQwNWEyYWE3NTFlMzg2ZTIwYTQzZTRhMzA4MjVi
-    NTk0ZDc2MDMwOTI1NjQ5NTJmZDdlNGQ5MjJhMzRmMWU3MDUzNTU2YjhkZGI1
-    MGVkZDY5ZmY2MDM1MWZlZDAxZTk5MWJmYzgwYWNiYjNhOGNjMTQ=
+    N2YxMDFhNTE0ZDM2Nzg3NWMzYWZhNDcyOWI3NDE4NjgwNGVkYmY0NWQzOGEz
+    NDA5ZGNiNjk3MzEwZjJlOTk3NmVhNGRlMzMyOWU3M2YwZjg0YTJjZGJmMGRh
+    MzJiMzg0ZDQ3NmZiYmU2M2JlNTRjZTZmOGRiMmI4MDJjZDFlOGM=
   data.tar.gz: !binary |-
-    NTA3NjFkNmFkOTEyOTZjZWE3N2MxYTFhMjc3YjMwMDY5ODU0MDVmMjZjYmFh
-    YjZmNGNjNmNmOTgyNmE1MTRmMmRjZjc5Njc2NmVhOTViYTViYTJjOGIzNzI5
-    ZDkxN2RlZjBkNmJiYjg2YmI4NmZhZGZhZDkzZWM3NzM4N2JhOTE=
+    YzkwMWRmY2Y0NDc3ODk2YmZkMDNhYzEzMjVmN2IxMzBmNDNmNmUyNjg3NDcw
+    MjQwOTU2ZDg4MTA0YTQ2YzE0OThhOGVhNGM4MzQxZmU2Yzg3ZjY0Y2I0ZjEw
+    NTQ0MzY5MzUxNTNhOGFlNjI1N2Y0NjRkYTM0MGU2NjAxYjJlYzc=

data/lib/event_aggregator.rb

@@ -1,4 +1,5 @@
 require "thread/pool"
+
 require "event_aggregator/version"
 require "event_aggregator/aggregator"
 require "event_aggregator/listener"

data/lib/event_aggregator/aggregator.rb

@@ -129,7 +129,6 @@ module EventAggregator
 			raise "Illegal message_type" if message_type == nil
 			raise "Illegal callback" unless callback.respond_to?(:call) && callback.arity == 1
 			
-			
 			@@producers[message_type] = callback
 		end
 		
@@ -155,7 +154,7 @@ module EventAggregator
 
 		private
 		def self.perform_message_job(data, callback, async, consisten_data)
-			case [async, consisten_data]
+			case [async, consisten_data || data == nil]
 			when [true, true]   then @@pool.process{ EventAggregator::MessageJob.new.perform(data,       callback) }
 			when [true, false]  then @@pool.process{ EventAggregator::MessageJob.new.perform(data.clone, callback) }
 			when [false, true]  then EventAggregator::MessageJob.new.perform(data,       callback)

data/lib/event_aggregator/message.rb

@@ -30,9 +30,9 @@ module EventAggregator
 		# data - The data that will be passed to the 
 		# EventAggregator::Listener objects
 		# async = true - Indicates if message should be published async or not
-		# consisten_data = false - Indicates if EventAggregator::Listener objects
+		# consisten_data = true - Indicates if EventAggregator::Listener objects
 		# should recieve a consistent object reference or clones.
-		def initialize(message_type, data, async = true, consisten_data = false)
+		def initialize(message_type, data, async = true, consisten_data = true)
 			raise "Illegal Message Type" if message_type == nil
 			
 			@message_type = message_type
@@ -47,9 +47,9 @@ module EventAggregator
 		def publish
 			Aggregator.message_publish( self )
 		end
-
+
 		# Public: Will provide data if a producer of this message_type is present.
-		#
+		#
 		# Returns Requested data if a producer is present. Nil otherwise.
 		def request
 			Aggregator.message_request( self )

data/lib/event_aggregator/version.rb

@@ -1,3 +1,3 @@
 module EventAggregator
-  VERSION = "1.1.4"
+  VERSION = "1.1.5"
 end

data/spec/lib/event_aggregator/aggregator_spec.rb

@@ -8,10 +8,15 @@ describe EventAggregator::Aggregator do
 	let(:callback)       { lambda{ |data| } }
 	let(:random_string)  { Faker::Internet.password }
 	let(:random_number)  { Faker::Number.number(rand(9)) }
-	
-	before(:each) do
+	let(:empty_object)   { Object.new }
+
+	before(:all) do
 		EventAggregator::Aggregator.reset
 	end
+
+	after(:each) do
+		EventAggregator::Aggregator.restart_pool
+	end
 	describe "self.register" do
 		describe 'legal parameters' do
 			it "no errors" do
@@ -229,7 +234,57 @@ describe EventAggregator::Aggregator do
 				EventAggregator::Aggregator.message_publish(message)
 			end
 
-			it 'run all callbacks for all message types' do
+			it 'runs all callbacks when data is different types' do
+				EventAggregator::Aggregator.register_all(listener, callback)
+				
+				message1 = EventAggregator::Message.new(message_type      , nil)
+				message2 = EventAggregator::Message.new(message_type + "2", random_number)
+				message3 = EventAggregator::Message.new(message_type + "3", random_string)
+				message4 = EventAggregator::Message.new(message_type + "4", empty_object)
+				message5 = EventAggregator::Message.new(message_type + "5", true)
+				message6 = EventAggregator::Message.new(message_type + "6", false)
+
+				expect(callback).to receive(:call).with(message1)
+				expect(callback).to receive(:call).with(message2)
+				expect(callback).to receive(:call).with(message3)
+				expect(callback).to receive(:call).with(message4)
+				expect(callback).to receive(:call).with(message5)
+				expect(callback).to receive(:call).with(message6)
+
+				EventAggregator::Aggregator.message_publish(message1)
+				EventAggregator::Aggregator.message_publish(message2)
+				EventAggregator::Aggregator.message_publish(message3)
+				EventAggregator::Aggregator.message_publish(message4)
+				EventAggregator::Aggregator.message_publish(message5)
+				EventAggregator::Aggregator.message_publish(message6)
+			end
+
+			it 'runs all callbacks when data is different types register one' do
+				EventAggregator::Aggregator.register(listener, message_type, callback)
+				
+				message1 = EventAggregator::Message.new(message_type, nil)
+				message2 = EventAggregator::Message.new(message_type, random_number)
+				message3 = EventAggregator::Message.new(message_type, random_string)
+				message4 = EventAggregator::Message.new(message_type, empty_object)
+				message5 = EventAggregator::Message.new(message_type, true)
+				message6 = EventAggregator::Message.new(message_type, false)
+				
+				expect(callback).to receive(:call).with(nil)
+				expect(callback).to receive(:call).with(random_number)
+				expect(callback).to receive(:call).with(random_string)
+				expect(callback).to receive(:call).with(empty_object)
+				expect(callback).to receive(:call).with(true)
+				expect(callback).to receive(:call).with(false)
+
+				EventAggregator::Aggregator.message_publish(message1)
+				EventAggregator::Aggregator.message_publish(message2)
+				EventAggregator::Aggregator.message_publish(message3)
+				EventAggregator::Aggregator.message_publish(message4)
+				EventAggregator::Aggregator.message_publish(message5)
+				EventAggregator::Aggregator.message_publish(message6)
+			end
+
+			it 'run all callbacks for all message types register all' do #Fails with seed: 34154
 				EventAggregator::Aggregator.register_all(listener, callback)
 
 				message1 = EventAggregator::Message.new(message_type      , data)
@@ -239,30 +294,13 @@ describe EventAggregator::Aggregator do
 				message5 = EventAggregator::Message.new(message_type + "5", data)
 				message6 = EventAggregator::Message.new(message_type + "6", data)
 
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message1.message_type)
-					expect(arg.data).to eql(message1.data)
-				}
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message2.message_type)
-					expect(arg.data).to eql(message2.data)
-				}
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message3.message_type)
-					expect(arg.data).to eql(message3.data)
-				}
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message4.message_type)
-					expect(arg.data).to eql(message4.data)
-				}
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message5.message_type)
-					expect(arg.data).to eql(message5.data)
-				}
-				expect(callback).to receive(:call) {|arg|
-					expect(arg.message_type).to eql(message6.message_type)
-					expect(arg.data).to eql(message6.data)
-				}
+
+				expect(callback).to receive(:call).with(message1)
+				expect(callback).to receive(:call).with(message2)
+				expect(callback).to receive(:call).with(message3)
+				expect(callback).to receive(:call).with(message4)
+				expect(callback).to receive(:call).with(message5)
+				expect(callback).to receive(:call).with(message6)
 
 
 				EventAggregator::Aggregator.message_publish(message1)
@@ -579,4 +617,70 @@ describe EventAggregator::Aggregator do
 			end
 		end
 	end
+
+	describe 'propagates fully' do
+		class TestClassSingle
+			include EventAggregator::Listener
+
+			def initialize
+				message_type_register("message_type", method(:test_method))
+			end
+
+			def test_method(data)
+				self.self_called(data)
+			end
+			def self_called(data)
+			end
+		end
+
+		class TestClassAll
+			include EventAggregator::Listener
+
+			def initialize
+				message_type_register_all(method(:test_method))
+			end
+
+			def test_method(data)
+				self.self_called(data)
+			end
+			def self_called(data)
+			end
+		end
+
+		it "calls method on test class single" do
+			test_class = TestClassSingle.new
+			expect(test_class).to receive(:self_called).with(data)
+			message = EventAggregator::Message.new("message_type", data)
+			EventAggregator::Aggregator.message_publish(message)
+		end
+
+		it "calls method on test class all" do
+			test_class = TestClassAll.new
+			message = EventAggregator::Message.new("message_type", data)
+			expect(test_class).to receive(:self_called){|e| expect(e.message_type).to eq("message_type") and expect(e.data).to eq(data)}
+			EventAggregator::Aggregator.message_publish(message)
+		end
+
+		it "calls method on test class single full-stack" do
+			test_class = TestClassSingle.new
+			expect(test_class).to receive(:self_called).with(data)
+			message = EventAggregator::Message.new("message_type", data)
+			message.publish
+		end
+
+		it "calls method on test class all full-stack" do
+			test_class = TestClassAll.new
+			message = EventAggregator::Message.new("message_type", data)
+			expect(test_class).to receive(:self_called){|e| expect(e.message_type).to eq("message_type") and expect(e.data).to eq(data)}
+			message.publish
+		end
+		it "calls method on mulitple" do
+			test_class = TestClassAll.new
+			test_class2 = TestClassSingle.new
+			message = EventAggregator::Message.new("message_type", data)
+			expect(test_class).to receive(:self_called){|e| expect(e.message_type).to eq("message_type") and expect(e.data).to eq(data)}
+			expect(test_class2).to receive(:self_called){|e| expect(e.message_type).to eq("message_type") and expect(e.data).to eq(data)}
+			message.publish
+		end
+	end
 end

data/spec/spec_helper.rb

@@ -10,13 +10,13 @@ Coveralls.wear!
 
 
 
-class Thread::Pool
-	
-	# Public: Overriding the process-call of the thread::pool so we can do tests better
-	def process (*args, &block)
-		block.call(*args)
-	end
-end
+# class Thread::Pool
+	
+# 	# Public: Overriding the process-call of the thread::pool so we can do tests better
+# 	def process (*args, &block)
+# 		block.call(*args)
+# 	end
+# end
 
 RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
@@ -29,3 +29,13 @@ RSpec.configure do |config|
   #     --seed 1234
   config.order = "random"
 end
+
+
+class EventAggregator::Aggregator
+
+  def self.restart_pool
+    @@pool.shutdown
+    @@pool = Thread.pool(4)
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: event_aggregator
 version: !ruby/object:Gem::Version
-  version: 1.1.4
+  version: 1.1.5
 platform: ruby
 authors:
 - Stephan Eriksen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-14 00:00:00.000000000 Z
+date: 2014-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler