event_aggregator 1.0.2 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9cb0b49b83b8a1b106aaa26fa5f58a3e9741bc7d
+  data.tar.gz: ec7a28b676d35655d1aa390add1a407a9e0ae372
+SHA512:
+  metadata.gz: ed2b5c2c8a43be676afb59a532dc876f203b04889c7d0a4cdde32fd33b6f296f5db78c4b313f94ef5a3f4a9d976f1ce29f4e6b9898e44a8a4474474aecc4ccab
+  data.tar.gz: ae05cc002ecbbc2558c8372b1ca092958635aedf616d1e17bbfcc51f0f1367349172b960178876714eb3eed71836ac3b2e9ea335a996acc6bd45a740c77c84b0

data/README.md

@@ -2,7 +2,7 @@
 
 
 [![Gem Version](https://badge.fury.io/rb/event_aggregator.png)][gem]
-[![Build Status](https://travis-ci.org/stephan-nordnes-eriksen/event_aggregator.png?branch=adding_travis_and_other)][travis]
+[![Build Status](https://travis-ci.org/stephan-nordnes-eriksen/event_aggregator.png?branch=master)][travis]
 [![Dependency Status](https://gemnasium.com/stephan-nordnes-eriksen/event_aggregator.png)][gemnasium]
 [![Code Climate](https://codeclimate.com/github/stephan-nordnes-eriksen/event_aggregator.png)][codeclimate]
 [![Coverage Status](https://coveralls.io/repos/stephan-nordnes-eriksen/event_aggregator/badge.png)][coveralls]

data/lib/event_aggregator/aggregator.rb

@@ -12,39 +12,63 @@ module EventAggregator
 	class Aggregator
 		class <<self; private :new; end
 
-		@@listeners = Hash.new{|h, k| h[k] = []}
-
-		# Public: Register an EventAggregator::Listener to recieve
+		@@listeners = Hash.new{|h, k| h[k] = Hash.new }
+		@@listeners_all = Hash.new
+		@@message_translation = Hash.new{|h, k| h[k] = Hash.new }
+		@@producers = Hash.new
+		# Public: Register an EventAggregator::Listener to receive
 		# 		  a specified message type
 		#
-		# listener - An EventAggregator::Listener which should recieve
+		# listener - An EventAggregator::Listener which should receive
 		# 			 the messages.
-		# message_type - The message type to recieve. Can be anything except nil.
+		# message_type - The message type to receive. Can be anything except nil.
 		# 				 Often it is preferable to use a string eg. "Message Type".
+		# callback - The callback that will be executed when messages of type equal
+		# 				message_type is published. Is executed with message.data as parameter.
+		#
 		def self.register( listener, message_type, callback )
+			raise "Illegal listener" unless listener.class < EventAggregator::Listener
+			raise "Illegal message_type" if message_type == nil
+			raise "Illegal callback" unless callback.respond_to?(:call)
+
+			@@listeners[message_type][listener] = callback
+		end
+
+
+		# Public: Register an EventAggregator::Listener to receive
+		# 		  every single message that is published.
+		#
+		# listener - An EventAggregator::Listener which should receive
+		# 			 the messages.
+		# callback - The callback that will be executed every time a message is published.
+		# 				will execute with the message as parameter.
+		#
+		def self.register_all( listener, callback )
+			raise "Illegal listener" unless listener.class < EventAggregator::Listener
 			raise "Illegal callback" unless callback.respond_to?(:call)
-			@@listeners[message_type] << [listener, callback] unless ! (listener.class < EventAggregator::Listener) || @@listeners[message_type].include?(listener)
+			@@listeners_all[listener] = callback
 		end
 
 		# Public: Unegister an EventAggregator::Listener to a
 		# 		  specified message type. The listener will no
 		# 		  longer get messages of this type.
 		#
-		# listener - The EventAggregator::Listener which should no longer recieve
+		# listener - The EventAggregator::Listener which should no longer receive
 		# 			 the messages.
 		# message_type - The message type to unregister for.
 		def self.unregister( listener, message_type )
-			@@listeners[message_type].delete_if{|value| value[0] == listener}
+			@@listeners[message_type].delete(listener)
 		end
 
 		# Public: As Unregister, but will unregister listener from all message types.
-		#
+		#!
 		# listener - The listener who should no longer get any messages at all,
 		# 			 regardless of type.
 		def self.unregister_all( listener )
-			@@listeners.each do |e|
-				e[1].delete_if{|value| value[0] == listener}
+			@@listeners.each do |key,value|
+				value.delete(listener)
 			end
+			@@listeners_all.delete(listener)
 		end
 
 		# Public: Will publish the specified message to all listeners
@@ -55,15 +79,87 @@ module EventAggregator
 		# consisten_data - true => the same object will be sent to all recievers. Default false
 		def self.message_publish ( message )
 			raise "Invalid message" unless message.respond_to?(:message_type) && message.respond_to?(:data)
-			@@listeners[message.message_type].each do |l|
-				if l[1].respond_to? :call
-					case [message.async, message.consisten_data]
-					when [true, true]   then EventAggregator::MessageJob.new.async.perform(message.data,       l[1])
-					when [true, false]  then EventAggregator::MessageJob.new.async.perform(message.data.clone, l[1])
-					when [false, true]  then EventAggregator::MessageJob.new.perform(      message.data,       l[1])
-					when [false, false] then EventAggregator::MessageJob.new.perform(      message.data.clone, l[1])
-					end
-				end
+			@@listeners[message.message_type].each do |listener, callback|	
+				perform_message_job(message.data, callback, message.async, message.consisten_data)
+			end
+			@@listeners_all.each do |listener,callback|
+				perform_message_job(message, callback, message.async, message.consisten_data)
+			end
+			@@message_translation[message.message_type].each do |message_type_new, callback|
+				EventAggregator::Message.new(message_type_new, callback.call(message.data)).publish
+			end
+		end
+
+
+		# Public: Resets the Aggregator to the initial state. This removes all registered listeners.
+		# Use EventAggregator::Aggregator.reset before each test when doing unit testing.
+		#
+		def self.reset
+			@@listeners = Hash.new{|h, k| h[k] = Hash.new}
+			@@listeners_all = Hash.new
+			@@message_translation = Hash.new{|h, k| h[k] = Hash.new }
+			@@producers = Hash.new
+		end
+
+		# Public: Will produce another message when a message type is published.
+		#
+		# message_type - Type of the message that will trigger a new message to be published.
+		# message_type_new - The type of the new message that will be published
+		# callback=lambda{|data| data} - The callback that will transform the data from message_type to message_type_new. Default: copy.
+		#
+		def self.translate_message_with(message_type, message_type_new, callback=lambda{|data| data})
+			raise "Illegal parameters" if message_type == nil || message_type_new == nil || !callback.respond_to?(:call) || callback.parameters.count != 1
+			raise "Illegal parameters, equal message_type and message_type_new" if message_type == message_type_new || message_type.eql?(message_type_new)
+
+			@@message_translation[message_type][message_type_new] = callback unless @@message_translation[message_type][message_type_new] == callback
+		end
+
+		
+		# Public: Registering a producer with the Aggregator. A producer will respond to message requests, a 
+		# 			request for a certain piece of data. 
+		#
+		# message_type - The message type that this callback will respond to.
+		# callback - The callback that returns data to the requester. Must have one parameter.
+		#
+		# Example:
+		#
+		# 	EventAggregator::Aggregator.register_producer("GetMultipliedByTwo", lambda{|data| data*2})
+		#
+		def self.register_producer(message_type, callback)
+			raise "Illegal message_type" if message_type == nil
+			raise "Illegal callback" unless callback.respond_to?(:call) && callback.parameters.count == 1
+			raise "Already defined producer" if @@producers[message_type]
+			
+			@@producers[message_type] = callback
+		end
+		
+		
+		# Public: Will remove a producer.
+		#
+		# message_type - The message type which will no longer respond to message requests.
+		#
+		def self.unregister_producer(message_type)
+			@@producers.delete(message_type)
+		end
+
+		
+		# Public: Request a piece of information.
+		#
+		# message - The message that will be requested based on its message type and data.
+		#
+		# Returns The data provided by a producer registered for this specific message type, or nil.
+		#
+		def self.message_request(message)
+			@@producers[message.message_type] ? @@producers[message.message_type].call(message.data) : nil
+		end
+
+		private
+		def self.perform_message_job(data, callback, async, consisten_data)
+			case [async, consisten_data]
+			when [true, true]   then EventAggregator::MessageJob.new.async.perform(data,       callback)
+			when [true, false]  then EventAggregator::MessageJob.new.async.perform(data.clone, callback)
+			when [false, true]  then EventAggregator::MessageJob.new      .perform(data,       callback)
+			when [false, false] then EventAggregator::MessageJob.new      .perform(data.clone, callback)
 			end
 		end
 	end

data/lib/event_aggregator/listener.rb

@@ -31,10 +31,20 @@ module EventAggregator
 			Aggregator.register( self, message_type, callback)
 		end
 
+		
+		# Public: Used to register listener for all message types. Every time a message is published
+		# the provided callback will be executed with the message as the content.
+		#
+		# callback - The method that will be invoked every time this message type is received. Must have: callback.respond_to? :call #=> true
+		#
+		def message_type_register_all(callback)
+			Aggregator.register_all(self, callback)
+		end
+
 		# Public: Used to remove a certain type of message from your listening types. Messages of this specific type will no longer
 		# invoke any callbacks.
 		#
-		# message_type -A string indicating the message type you no longer want to receive.
+		# message_type - A string indicating the message type you no longer want to receive.
 		#
 		# Examples
 		#
@@ -43,5 +53,29 @@ module EventAggregator
 		def message_type_unregister( message_type )
 			Aggregator.unregister(self, message_type)
 		end
+
+		
+		# Public: Will unregister the listener from all message types as well as the message_type_register_all.
+		# Listener will no longer recieve any callbacks when messages of any kind are published.
+		#
+		def message_type_unregister_all
+			Aggregator.unregister_all(self)
+		end
+
+
+		
+		# Public: Duplicate some text an arbitrary number of times.
+		#
+		# message_type - A string indicating the the message type the callback will respond to
+		# callback - The callback returning data whenever a message requests the message_type.
+		#
+		# Excample: 
+		# 			listener.producer_register("MultiplyByTwo", lambda{|data| return data*2})
+		# 			number = EventAggregator::Message.new("MultiplyByTwo", 3)
+		# 			# => 6
+		#
+		def producer_register(message_type, callback)
+			Aggregator.register_producer(message_type, callback)
+		end
 	end
 end

data/lib/event_aggregator/message.rb

@@ -47,5 +47,12 @@ 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 )
+		end
 	end
 end

data/lib/event_aggregator/version.rb

@@ -1,3 +1,3 @@
 module EventAggregator
-  VERSION = "1.0.2"
+  VERSION = "1.1.0"
 end

data/spec/lib/event_aggregator/aggregator_spec.rb

@@ -6,37 +6,48 @@ describe EventAggregator::Aggregator do
 	let(:message_type)   { Faker::Name.name }
 	let(:data)           { Faker::Name.name }
 	let(:callback)       { lambda{ |data| } }
-
+	let(:random_string)  { Faker::Internet.password }
+	let(:random_number)  { Faker::Number.number(rand(9)) }
+	
 	before(:each) do
-		EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+		EventAggregator::Aggregator.reset
 	end
 	describe "self.register" do
 		describe 'legal parameters' do
-			it 'registered at correct place' do
-				EventAggregator::Aggregator.register(listener, message_type, callback)
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to include([listener, callback])
+			it "no errors" do
+				expect{EventAggregator::Aggregator.register(listener, message_type, callback)}.to_not raise_error
 			end
-
-			it 'not be registered in wrong place' do
+			it "is stored" do
+				expect{EventAggregator::Aggregator.register(listener, message_type, callback)}.to change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			end
+			it "overwrite previous callback" do
+				callback2 = lambda { |data| }
 				EventAggregator::Aggregator.register(listener, message_type, callback)
-				EventAggregator::Aggregator.class_variable_get(:@@listeners).each do |e|
-					if e[0] == message_type
-						expect(e[1]).to include([listener, callback])
-					else
-						expect(e[1]).to_not include([listener, callback])
-					end
-				end
+				EventAggregator::Aggregator.register(listener, message_type, callback2)
+				
+				expect(callback).to_not receive(:call)
+				expect(callback2).to receive(:call)
+
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type, data))
 			end
 		end
 		describe 'illegal parameters' do
-			it 'not allow nil as message type' do
-				expect{EventAggregator::Aggregator.register(nil, message_type, callback)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			it 'message_type raise error' do
+				expect{EventAggregator::Aggregator.register(listener, nil, callback)}.to raise_error
+			end
+			it "listener raise error" do
+				expect{EventAggregator::Aggregator.register(nil                                  , message_type, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register(EventAggregator::Message.new("a","b"), message_type, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register(random_string                        , message_type, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register(random_number                        , message_type, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register(2.0                                  , message_type, callback)}.to raise_error
 			end
-			it 'not allow non-listener to register' do
-				expect{EventAggregator::Aggregator.register(EventAggregator::Message.new("a","b"), message_type, callback)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
-				expect{EventAggregator::Aggregator.register("string", message_type, callback)}.to_not                              change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
-				expect{EventAggregator::Aggregator.register(1, message_type, callback)}.to_not                                     change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
-				expect{EventAggregator::Aggregator.register(2.0, message_type, callback)}.to_not                                   change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			it 'callback raise error' do
+				expect{EventAggregator::Aggregator.register(listener, message_type, nil                                  )}.to raise_error
+				expect{EventAggregator::Aggregator.register(listener, message_type, EventAggregator::Message.new("a","b"))}.to raise_error
+				expect{EventAggregator::Aggregator.register(listener, message_type, random_string                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register(listener, message_type, random_number                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register(listener, message_type, 2.0                                  )}.to raise_error
 			end
 		end
 	end
@@ -54,13 +65,15 @@ describe EventAggregator::Aggregator do
 			end
 			it 'keep listener in unrelated lists' do
 				message_type2 = message_type + " different"
-				
+
 				EventAggregator::Aggregator.register(listener, message_type, callback)
 				EventAggregator::Aggregator.register(listener, message_type2, callback)
-				
+
 				EventAggregator::Aggregator.unregister(listener, message_type)
-				
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include([listener, callback])
+
+				expect(callback).to receive(:call).once
+
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type2,data))
 			end
 		end
 		describe 'unregitering nonregisterd listener' do
@@ -75,17 +88,19 @@ describe EventAggregator::Aggregator do
 				EventAggregator::Aggregator.register(listener1, message_type1, callback)
 				EventAggregator::Aggregator.register(listener2, message_type2, callback)
 				EventAggregator::Aggregator.register(listener3, message_type3, callback)
-				
+
 				#Touching hash
 				EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]
 
 				expect{EventAggregator::Aggregator.unregister(listener1, message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
 				expect{EventAggregator::Aggregator.unregister(listener2, message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
 				expect{EventAggregator::Aggregator.unregister(listener3, message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				
+				expect(callback).to receive(:call).exactly(3).times
 
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type1]).to include([listener1, callback])
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include([listener2, callback])
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type3]).to include([listener3, callback])
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type1,data))
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type2,data))
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type3,data))
 			end
 		end
 		describe 'unregitering listener from wrong message type' do
@@ -116,7 +131,7 @@ describe EventAggregator::Aggregator do
 				EventAggregator::Aggregator.register(listener, message_type, callback)
 
 				EventAggregator::Aggregator.unregister_all(listener)
-				
+
 				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to_not  include([listener, callback])
 			end
 			it "not unregister wrong listener" do
@@ -132,12 +147,12 @@ describe EventAggregator::Aggregator do
 				EventAggregator::Aggregator.register(listener3, message_type2, callback)
 				EventAggregator::Aggregator.register(listener4, message_type3, callback)
 
-				
+
 				EventAggregator::Aggregator.unregister_all(listener)
 
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to include([listener2, callback])
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include([listener3, callback])
-				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type3]).to include([listener4, callback])
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type][listener2]).to eq(callback)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2][listener3]).to eq(callback)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type3][listener4]).to eq(callback)
 			end
 		end
 		describe "unregistering listener registered for several message types" do
@@ -152,6 +167,15 @@ describe EventAggregator::Aggregator do
 				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to_not include([listener, callback])
 			end
 		end
+		describe "unregistering listener registered for all" do
+			it "unregister from all" do
+				EventAggregator::Aggregator.register_all(listener, callback)
+
+				EventAggregator::Aggregator.unregister_all(listener)
+
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners_all)).to_not include([listener, callback])
+			end
+		end
 	end
 
 	describe "self.message_publish" do
@@ -166,7 +190,7 @@ describe EventAggregator::Aggregator do
 			end
 			it 'not run incorrect callback' do
 				message_type2 = message_type + " different"
-				
+
 				EventAggregator::Aggregator.register(listener, message_type, callback)
 				message = EventAggregator::Message.new(message_type2, data)
 
@@ -191,14 +215,71 @@ describe EventAggregator::Aggregator do
 
 				EventAggregator::Aggregator.message_publish(message)
 			end
+			it 'run all callbacks from register_all' do
+				listener2 = listener_class.new
+				callback2 = lambda{ |message| }
+				EventAggregator::Aggregator.register_all(listener, callback)
+				EventAggregator::Aggregator.register_all(listener2, callback2)
+
+				message = EventAggregator::Message.new(message_type, data, true, true)
+
+				expect(callback).to receive(:call).with(message)
+				expect(callback2).to receive(:call).with(message)
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+
+			it 'run all callbacks for all message types' do
+				EventAggregator::Aggregator.register_all(listener, callback)
+
+				message1 = EventAggregator::Message.new(message_type      , data)
+				message2 = EventAggregator::Message.new(message_type + "2", data)
+				message3 = EventAggregator::Message.new(message_type + "3", data)
+				message4 = EventAggregator::Message.new(message_type + "4", data)
+				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)
+				}
+
+
+				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
 		end
 		describe 'illegal parameters' do
 			it 'non-message type' do
 				expect{EventAggregator::Aggregator.message_publish("string")}.to raise_error
-				expect{EventAggregator::Aggregator.message_publish(1)}.to        raise_error
+				expect{EventAggregator::Aggregator.message_publish(1)}       .to raise_error
 				expect{EventAggregator::Aggregator.message_publish(listener)}.to raise_error
-				expect{EventAggregator::Aggregator.message_publish()}.to         raise_error
-				expect{EventAggregator::Aggregator.message_publish(nil)}.to      raise_error
+				expect{EventAggregator::Aggregator.message_publish()}        .to raise_error
+				expect{EventAggregator::Aggregator.message_publish(nil)}     .to raise_error
 			end
 		end
 		describe 'consisten_data behaviour' do
@@ -209,7 +290,7 @@ describe EventAggregator::Aggregator do
 
 				EventAggregator::Aggregator.register(listener, message_type, callback1)
 				EventAggregator::Aggregator.register(listener2, message_type, callback2)
-				
+
 				message = EventAggregator::Message.new(message_type, data, false, true)
 
 				expect(callback1).to receive(:call) {|arg| expect(arg).to equal(data)}
@@ -224,7 +305,7 @@ describe EventAggregator::Aggregator do
 
 				EventAggregator::Aggregator.register(listener, message_type, callback1)
 				EventAggregator::Aggregator.register(listener2, message_type, callback2)
-				
+
 				message = EventAggregator::Message.new(message_type, data, false, false)
 
 				expect(callback1).to receive(:call) {|arg| expect(arg).to_not equal(data)}
@@ -234,12 +315,12 @@ describe EventAggregator::Aggregator do
 			end
 			it 'objects have same values when false' do
 				listener2 = listener_class.new
-				callback1 = lambda{|data| data ="no"}
-				callback2 = lambda{|data| data ="no"}
+				callback1 = lambda{|data| data = "no"}
+				callback2 = lambda{|data| data = "no"}
 
 				EventAggregator::Aggregator.register(listener, message_type, callback1)
 				EventAggregator::Aggregator.register(listener2, message_type, callback2)
-				
+
 				message = EventAggregator::Message.new(message_type, data, false, false)
 
 				expect(callback1).to receive(:call) {|arg| expect(arg).to eq(data)}
@@ -249,4 +330,253 @@ describe EventAggregator::Aggregator do
 			end
 		end
 	end
-end
+
+	describe "self.register_all" do
+		describe 'legal parameters' do
+			it 'registered at correct place' do
+				EventAggregator::Aggregator.register_all(listener, callback)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners_all)).to include(listener)
+			end
+
+			it 'not register same listener multiple times' do
+				EventAggregator::Aggregator.register_all(listener, callback)
+				expect{EventAggregator::Aggregator.register_all(listener, callback)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners_all)}
+			end
+			it "overwrite previous callback" do
+				callback2 = lambda { |data| }
+				EventAggregator::Aggregator.register_all(listener, callback)
+				EventAggregator::Aggregator.register_all(listener, callback2)
+				
+				expect(callback).to_not receive(:call)
+				expect(callback2).to receive(:call)
+
+				EventAggregator::Aggregator.message_publish(EventAggregator::Message.new(message_type, data))
+			end
+		end
+		describe 'illegal parameters' do
+			it 'listener raise error' do
+				expect{EventAggregator::Aggregator.register_all(nil,                                   callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(EventAggregator::Message.new("a","b"), callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(random_string,                         callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(random_number,                         callback)}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(2.0,                                   callback)}.to raise_error
+			end
+			it 'callback raise error' do
+				expect{EventAggregator::Aggregator.register_all(listener, nil                                  )}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(listener, EventAggregator::Message.new("a","b"))}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(listener, random_string                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(listener, random_number                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register_all(listener, 2.0                                  )}.to raise_error
+			end
+		end
+	end
+
+	describe "self.reset" do
+		it 'removes all listenes' do
+			EventAggregator::Aggregator.register(listener, message_type, callback)
+			EventAggregator::Aggregator.register_all(listener, callback)
+			EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+			EventAggregator::Aggregator.register_producer(message_type, callback)
+
+			EventAggregator::Aggregator.reset
+
+			expect(EventAggregator::Aggregator.class_variable_get(:@@listeners))          .to be_empty
+			expect(EventAggregator::Aggregator.class_variable_get(:@@listeners_all))      .to be_empty
+			expect(EventAggregator::Aggregator.class_variable_get(:@@message_translation)).to be_empty
+			expect(EventAggregator::Aggregator.class_variable_get(:@@producers))          .to be_empty
+		end
+
+		it 'listener not receive messages' do
+			listener2 = listener_class.new
+			callback2 = lambda{|data|}
+			message = EventAggregator::Message.new(message_type, data)
+			EventAggregator::Aggregator.register(listener, message_type, callback)
+			EventAggregator::Aggregator.register_all(listener2, callback2)
+
+			EventAggregator::Aggregator.reset
+
+			expect(callback).to_not receive(:call)
+			expect(callback2).to_not receive(:call)
+
+			EventAggregator::Aggregator.message_publish(message)
+		end
+		it "producers not responding" do
+			EventAggregator::Aggregator.register_producer(message_type, callback)
+			message = EventAggregator::Message.new(message_type, data)
+
+			EventAggregator::Aggregator.reset
+
+			expect(callback).to_not receive(:call)
+
+			EventAggregator::Aggregator.message_request(message)
+		end
+	end
+
+	describe "self.translate_message_with" do
+		describe 'legal parameters' do
+			it "creates new message from type" do
+				EventAggregator::Aggregator.register(listener, message_type + " different", callback)
+				message = EventAggregator::Message.new(message_type, data)
+
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+
+				expect(callback).to receive(:call).with(data)
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+
+			it "listener receives transformed data" do
+				EventAggregator::Aggregator.register(listener, message_type + " different", callback)
+				message = EventAggregator::Message.new(message_type, "data")
+
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", lambda{|data| "other data"})
+
+				expect(callback).to receive(:call).with("other data")
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+
+			it "multiple assigns not change list" do
+				message = EventAggregator::Message.new(message_type, data)
+
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@message_translation)}
+			end
+
+			it "multiple assigns not publish several messages" do
+				EventAggregator::Aggregator.register(listener, message_type + " different", callback)
+				message = EventAggregator::Message.new(message_type, data)
+
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+
+				expect(callback).to receive(:call).with(data).once
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+
+			it "multiple assigns to update callback" do
+				EventAggregator::Aggregator.register(listener, message_type + " different", callback)
+				message = EventAggregator::Message.new(message_type, "data")
+
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different")
+				EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", lambda{|data| "changed data"})
+
+				expect(callback).to receive(:call).with("changed data").once
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+		end
+		describe 'illegal parameters' do
+			it "callback raise error" do
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", nil)}                 .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", random_number)}       .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", random_string)}       .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", Object.new)}          .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", lambda{})}            .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, message_type + " different", lambda{ "whatever" })}.to raise_error
+			end
+
+			it "message type nil raise error" do
+				expect{EventAggregator::Aggregator.translate_message_with(nil,          message_type)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(message_type, nil)}         .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(nil,          nil)}         .to raise_error
+			end
+
+			#Very VERY important that these raise errors!
+			it "equal arguments no callback raise error" do
+				expect{EventAggregator::Aggregator.translate_message_with(message_type,  message_type)} .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_string, random_string)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_number, random_number)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_number, random_number)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with("string",      "string")}     .to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(1,             1)}            .to raise_error
+			end
+
+			it "equal arguments with callback raise error" do
+				expect{EventAggregator::Aggregator.translate_message_with(message_type,  message_type,  callback)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_string, random_string, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_number, random_number, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(random_number, random_number, callback)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with("string",      "string",      callback)}.to raise_error
+				expect{EventAggregator::Aggregator.translate_message_with(1,             1,             callback)}.to raise_error
+			end
+		end
+	end
+
+	describe "self.register_producer" do
+		describe 'illegal parameters' do
+			it 'callback raise error' do
+				expect{EventAggregator::Aggregator.register_producer(message_type, nil                                  )}.to raise_error
+				expect{EventAggregator::Aggregator.register_producer(message_type, EventAggregator::Message.new("a","b"))}.to raise_error
+				expect{EventAggregator::Aggregator.register_producer(message_type, random_string                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register_producer(message_type, random_number                        )}.to raise_error
+				expect{EventAggregator::Aggregator.register_producer(message_type, 2.0                                  )}.to raise_error
+			end
+		end
+	end
+
+	describe "self.unregister_producer" do
+		it "producers not responding" do
+			EventAggregator::Aggregator.register_producer(message_type, callback)
+			message = EventAggregator::Message.new(message_type, data)
+
+			EventAggregator::Aggregator.unregister_producer(message_type)
+
+			expect(callback).to_not receive(:call)
+
+			EventAggregator::Aggregator.message_request(message)
+		end
+	end
+
+
+	describe "self.message_request" do
+		describe 'legal parameters' do
+			it 'run correct callback' do
+				EventAggregator::Aggregator.register_producer(message_type, callback)
+				message = EventAggregator::Message.new(message_type, data)
+
+				expect(callback).to receive(:call).with(data)
+
+				EventAggregator::Aggregator.message_request(message)
+			end
+			it 'not run incorrect callback' do
+				message_type2 = message_type + " different"
+
+				EventAggregator::Aggregator.register_producer(message_type, callback)
+				message = EventAggregator::Message.new(message_type2, data)
+
+				expect(callback).to_not receive(:call).with(data)
+
+				EventAggregator::Aggregator.message_request(message)
+			end
+
+			it 'run correct callback in list' do
+				message_type2 = message_type + " different"
+
+				callback2 = lambda{|data|}
+
+				EventAggregator::Aggregator.register_producer(message_type, callback)
+				EventAggregator::Aggregator.register_producer(message_type2, callback2)
+
+				message = EventAggregator::Message.new(message_type, data)
+
+				expect(callback).to receive(:call).with(data)
+				expect(callback2).to_not receive(:call)
+
+				EventAggregator::Aggregator.message_request(message)
+			end
+
+		end
+		describe 'illegal parameters' do
+			it 'non-message type' do
+				expect{EventAggregator::Aggregator.message_request("string")}.to raise_error
+				expect{EventAggregator::Aggregator.message_request(1)}       .to raise_error
+				expect{EventAggregator::Aggregator.message_request(listener)}.to raise_error
+				expect{EventAggregator::Aggregator.message_request()}        .to raise_error
+				expect{EventAggregator::Aggregator.message_request(nil)}     .to raise_error
+			end
+		end
+	end
+end

data/spec/lib/event_aggregator/listener_spec.rb

@@ -3,34 +3,39 @@ require 'spec_helper'
 
 # Public: Some ruby trickery to be able to test private methods
 #
+# Example:
+# whatever_object.class.publicize_methods do
+# #... execute private methods
+# end
 class Class
-  def publicize_methods
-    saved_private_instance_methods = self.private_instance_methods
-    self.class_eval { public *saved_private_instance_methods }
-    yield
-    self.class_eval { private *saved_private_instance_methods }
-  end
+	def publicize_methods
+		saved_private_instance_methods = self.private_instance_methods
+		self.class_eval { public *saved_private_instance_methods }
+		yield
+		self.class_eval { private *saved_private_instance_methods }
+	end
 end
 
 describe EventAggregator::Listener do
-	let(:listener)       { (Class.new { include EventAggregator::Listener }).new }
-	let(:listener_class) { Class.new { include EventAggregator::Listener } }
-	let(:message_type)   { Faker::Name.name }
-	let(:lambda_method)  { lambda { |data| }}
-	let(:data)  		 { Faker::Name.name }
+	let(:listener)           { (Class.new { include EventAggregator::Listener }).new }
+	let(:listener_class)     { Class.new { include EventAggregator::Listener } }
+	let(:message_type)       { Faker::Name.name }
+	let(:callback)      { lambda { |data| } }
+	let(:data)  		     { Faker::Name.name }
+	let(:recieve_all_method) { lambda { |message| } }
 
 	before(:each) do
-		EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+		EventAggregator::Aggregator.reset
 		@message = EventAggregator::Message.new(message_type, data)
 	end
 
-	describe '.message_type_to_receive_add' do
+	describe '.message_type_register' do
 		describe 'legal parameters' do
 			it 'invoke aggregator register' do
-				expect(EventAggregator::Aggregator).to receive(:register).with(listener, message_type, lambda_method)
-				
+				expect(EventAggregator::Aggregator).to receive(:register).with(listener, message_type, callback)
+
 				listener.class.publicize_methods do
-					listener.message_type_register(message_type, lambda_method)
+					listener.message_type_register(message_type, callback)
 				end
 			end
 		end
@@ -44,12 +49,12 @@ describe EventAggregator::Listener do
 		end
 	end
 
-	describe '.message_type_to_receive_remove' do
+	describe '.message_type_unregister' do
 		describe 'legal parameters' do
 			it 'invoke aggregator unregister' do
 				listener.class.publicize_methods do
-					listener.message_type_register(message_type, lambda_method)
-					
+					listener.message_type_register(message_type, callback)
+
 					expect(EventAggregator::Aggregator).to receive(:unregister).with(listener, message_type)
 
 					listener.message_type_unregister(message_type)
@@ -57,4 +62,39 @@ describe EventAggregator::Listener do
 			end
 		end
 	end
+
+	describe '.message_type_register_all' do
+		describe 'legal parameters' do
+			it 'invoke aggregator unregister_all' do
+				listener.class.publicize_methods do
+					expect(EventAggregator::Aggregator).to receive(:register_all).with(listener,callback)
+
+					listener.message_type_register_all(callback)
+				end
+			end
+		end
+	end
+
+	describe '.message_type_unregister_all' do
+		describe 'legal parameters' do
+			it 'invoke aggregator unregister' do
+				listener.class.publicize_methods do
+					expect(EventAggregator::Aggregator).to receive(:unregister_all).with(listener)
+
+					listener.message_type_unregister_all()
+				end
+			end
+		end
+	end
+
+	describe ".message_type_producer_register" do
+		describe 'legal parameters' do
+			it "invoke aggregator register_producer" do
+				expect(EventAggregator::Aggregator).to receive(:register_producer).with(message_type, callback)
+				listener.class.publicize_methods do
+					listener.producer_register(message_type, callback)
+				end
+			end
+		end
+	end
 end

data/spec/lib/event_aggregator/message_spec.rb

@@ -1,47 +1,63 @@
 require 'spec_helper'
 
 describe EventAggregator::Message do
-    describe '.publish' do
-		let(:message_type) {Faker::Name.name}
-		let(:data)         {Faker::Name.name}
-		let(:listener_class) { (Class.new { include EventAggregator::Listener }) }
-		let(:callback)		 { lambda{ |data| } }
-
-    	before(:each) do
-			EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+	let(:message_type)   { Faker::Name.name }
+	let(:data)           { Faker::Name.name }
+	let(:listener_class) { (Class.new { include EventAggregator::Listener }) }
+	let(:callback)		 { lambda{ |data| } }
+
+	before(:each) do
+		EventAggregator::Aggregator.reset
+	end
+	describe '.initialize' do
+		describe 'legal parameters' do
+			it 'allows nil data' do
+				expect{EventAggregator::Message.new(message_type, nil)}.to_not raise_error
+			end
+			it 'initialize data publicly available' do
+				message = EventAggregator::Message.new(message_type, data)
+
+				expect(message.message_type).to equal(message_type)
+				expect(message.data).to         equal(data)
+			end
+		end
+		describe 'illegal parameters' do
+			it 'require initialize data' do
+				expect{EventAggregator::Message.new(message_type)}      .to     raise_error
+				expect{EventAggregator::Message.new(data)}              .to     raise_error
+				expect{EventAggregator::Message.new(message_type, data)}.to_not raise_error
+			end
+			it 'non-nil message_type' do
+				expect{EventAggregator::Message.new(nil, data)}.to raise_error
+			end
+		end
+	end
+
+	describe '.publish' do
+		before(:each) do
 			@listener_one = listener_class.new
 			@listener_two = listener_class.new
-			
+
 			EventAggregator::Aggregator.register(@listener_one, message_type, callback)
 			EventAggregator::Aggregator.register(@listener_two, message_type+" different", callback)
 		end
 
-    	it 'should invoke message_publish on aggregator' do
-    		message = EventAggregator::Message.new(message_type, data)
-    		
-    		expect(EventAggregator::Aggregator).to receive(:message_publish).with(message)
+		it 'invoke message_publish on aggregator' do
+			message = EventAggregator::Message.new(message_type, data)
 
-    		message.publish
-    	end
-	end
+			expect(EventAggregator::Aggregator).to receive(:message_publish).with(message)
 
-	describe 'self.new' do
-		let(:message_type) {Faker::Name.name}
-		let(:data)         {Faker::Name.name}
-			
-		it 'should require initialize data' do
-			expect{EventAggregator::Message.new(message_type)}.to           raise_error
-			expect{EventAggregator::Message.new(data)}.to                   raise_error
-			expect{EventAggregator::Message.new(message_type, data)}.to_not raise_error
+			message.publish
 		end
-		it 'should have non-nil message_type' do
-			expect{EventAggregator::Message.new(nil, data)}.to raise_error
-		end
-		it 'should have initialize data publicly available' do
+	end
+
+	describe ".request" do
+		it 'invoke message_request on aggregator' do
 			message = EventAggregator::Message.new(message_type, data)
-			
-			expect(message.message_type).to equal(message_type)
-			expect(message.data).to         equal(data)
+
+			expect(EventAggregator::Aggregator).to receive(:message_request).with(message)
+
+			message.request
 		end
 	end
 end

metadata

@@ -1,132 +1,117 @@
 --- !ruby/object:Gem::Specification
 name: event_aggregator
 version: !ruby/object:Gem::Version
-  version: 1.0.2
-  prerelease: 
+  version: 1.1.0
 platform: ruby
 authors:
 - Stephan Eriksen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-29 00:00:00.000000000 Z
+date: 2014-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0.beta1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 3.0.0.beta1
 - !ruby/object:Gem::Dependency
   name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.2.2
 - !ruby/object:Gem::Dependency
   name: faker
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '0.7'
 - !ruby/object:Gem::Dependency
   name: sucker_punch
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
 description: A simple Ruby event aggregator.
@@ -136,9 +121,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .travis.yml
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -159,27 +144,26 @@ files:
 homepage: https://github.com/stephan-nordnes-eriksen/event_aggregator
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Event aggregator for Ruby.
 test_files:
 - spec/lib/event_aggregator/aggregator_spec.rb