event_aggregator 0.0.1 → 0.0.2

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.idea/*

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Guardfile

@@ -0,0 +1,6 @@
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/README.md

@@ -1,5 +1,7 @@
 # EventAggregator
 
+#### Note: This is a very early release and subject to many changes. It is currently not tested propperly, and there are several issues ranging from potential dead-locks to upcoming refactoring.
+
 The 'event_aggregator' gem is a gem for using the event aggregator pattern in Ruby. 
 
 An event aggregator is essentially a message passing service that aims at decoupeling object communication and that lets 
@@ -28,9 +30,9 @@ Or install it yourself as:
 	class Foo
 		include EventAggregator::Listener
 		def initialize()
-			message_type_to_recieve_add( "foo", lambda{|data| puts "bar" } )
+			message_type_to_receive_add( "foo", lambda{|data| puts "bar" } )
 
-			message_type_to_recieve_add( "foo2", method(:handle_message) )
+			message_type_to_receive_add( "foo2", method(:handle_message) )
 		end
 
 		def handle_message(data)
@@ -57,5 +59,6 @@ Or install it yourself as:
 
 ## Todo:
 
+ - Adding tests
  - Enable threaded message passing for higher performance. 
- - Improving the readme and documentation in the gem.
+ - Improving the readme and documentation in the gem.

data/event_aggregator.gemspec

@@ -18,6 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_development_dependency 'bundler', "~> 1.3"
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'guard-rspec'
+  spec.add_development_dependency 'factory_girl'
+  spec.add_development_dependency 'faker'
 end

data/lib/event_aggregator/aggregator.rb

@@ -1,27 +1,41 @@
+#require 'singleton'
+
 module EventAggregator
+
+	# Public: TODO: Could potentially turn this into a module.
+	#
+	# 	module OtherSingleton
+	# 		@index = -1
+	# 		@colors = %w{ red green blue }
+	# 		def self.change
+	# 			@colors[(@index += 1) % @colors.size]
+	# 		end
+	# 	end
 	class Aggregator
-		@@listeners = Hash.new([])
+		#include Singleton
+		class <<self; private :new; end
+		#TODO: Figure out how to do singleton pattern properly
 
-		@@message_types = Hash.new
+		@@listeners = Hash.new{|h, k| h[k] = []}
 
 		def self.register( listener, message_type )
-			@@listeners[message_type] << listener unless @@listeners[message_type].include?(listener)
+			@@listeners[message_type] << listener unless ! (listener.class < EventAggregator::Listener) || @@listeners[message_type].include?(listener)
 		end
 
 		def self.unregister( listener, message_type )
 			@@listeners[message_type].delete listener
 		end
-
+		def self.unregister_all( listener )
+			@@listeners.each do |e|
+				e[1].delete(listener)
+			end
+		end
 		def self.message_publish ( message )
-			return "Not a valid message" unless message.is_a? EventAggregator::Message
+			raise "Invalid message" unless message.is_a? EventAggregator::Message
 
 			@@listeners[message.message_type].each do |l|
-				l.recieve_message message
+				l.receive_message message
 			end
 		end
-
-		def self.register_message_type(message_type)
-			@@message_types[message_types] = [] unless @@message_types[message_types]
-		end
 	end
 end

data/lib/event_aggregator/listener.rb

@@ -1,5 +1,5 @@
 module EventAggregator
-	# Public: A module you can include or extend to recieve messages from
+	# Public: A module you can include or extend to receive messages from
 	# the event Aggregator system.
 	#
 	# Examples
@@ -9,7 +9,7 @@ module EventAggregator
 	# 		...
 	# 		def initialize()
 	# 			...
-	# 			message_type_to_recieve_add( "foo", lambda{ puts "bar" } )
+	# 			message_type_to_receive_add( "foo", lambda{ puts "bar" } )
 	# 		end
 	# 		...
 	#  	end
@@ -43,7 +43,7 @@ module EventAggregator
 
 
 		# Public: DEPRICATED: Adding extra initialize to the class so that we make sure new objects are added to the EventAggregators registry.
-		# This whole hack-deal is possibly not nescessary. Can be omited with a simple "register" when you add a new "recieve message_type"
+		# This whole hack-deal is possibly not nescessary. Can be omited with a simple "register" when you add a new "receive message_type"
 		#
 		# base - The class object for the class including the Listener module
 		#
@@ -61,7 +61,7 @@ module EventAggregator
 			end
 		end
 
-		def recieve_message( message )
+		def receive_message( message )
 			m = event_listener_listens_to[message.message_type]
 
 			m.call(message.data) if m.respond_to? :call #Should not need the check here, however who knows what kind of conurrency issues we might have.
@@ -72,18 +72,18 @@ module EventAggregator
 		def event_listener_listens_to
 			@event_listener_listens_to ||= Hash.new
 		end
-		# public: Use to add message types you want to recieve. Overwirte existing callback when existing message type is given.
+		# public: Use to add message types you want to receive. Overwirte existing callback when existing message type is given.
 		#
-		# message_type 	- A string indicating the message type you want to recieve from the event aggregrator. Can actually be anything.
-		# callback 		- The method that will be invoked every time this message type is recieved. Must have: callback.respond_to? :call #=> true
+		# message_type 	- A string indicating the message type you want to receive from the event aggregrator. Can actually be anything.
+		# callback 		- The method that will be invoked every time this message type is received. Must have: callback.respond_to? :call #=> true
 		#
 		# Examples
 		#
-		#   message_type_to_recieve_add("foo", method(:my_class_method))
-		#   message_type_to_recieve_add("foo", lambda { puts "foo" })
-		#   message_type_to_recieve_add("foo", Proc.new { puts "foo" })
+		#   message_type_to_receive_add("foo", method(:my_class_method))
+		#   message_type_to_receive_add("foo", lambda { puts "foo" })
+		#   message_type_to_receive_add("foo", Proc.new { puts "foo" })
 		#
-		def message_type_to_recieve_add( message_type, callback )
+		def message_type_to_receive_add( message_type, callback )
 			event_listener_listens_to[message_type] = callback #unless event_listener_listens_to[message_type] #It makes more sence to overwrite in the case it already exists.
 			Aggregator.register( self, message_type )
 		end
@@ -91,13 +91,13 @@ module EventAggregator
 		# 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 recieve.
+		# message_type -A string indicating the message type you no longer want to receive.
 		#
 		# Examples
 		#
-		#   message_type_to_recieve_remove("foo")
+		#   message_type_to_receive_remove("foo")
 		#
-		def message_type_to_recieve_remove( message_type )
+		def message_type_to_receive_remove( message_type )
 			event_listener_listens_to[message_type] = nil
 			Aggregator.unregister(self, message_type)
 		end

data/lib/event_aggregator/message.rb

@@ -4,6 +4,8 @@ module EventAggregator
 		@message_type = nil
 		@data = nil
 		def initialize(message_type, data)
+			raise "Illegal Message Type" if !message_type
+			
 			@message_type = message_type
 			@data = data
 		end

data/lib/event_aggregator/version.rb

@@ -1,3 +1,3 @@
 module EventAggregator
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/factories.rb

@@ -0,0 +1,22 @@
+require 'factory_girl'
+require 'faker'
+require 'event_aggregator'
+
+
+# Public: Not really used. Might not be needed at all. The same 
+# 		  goes for FactoryGirl in general. Might not be needed.
+#
+class DummyListener
+	include EventAggregator::Listener
+end
+
+FactoryGirl.define do	
+	factory :listener, class: DummyListener do
+
+	end
+	factory :message do
+		message_type { Faker::Name.name }
+		data { Faker::Commerce.product_name } #TODO: This bracket should be unnescecary
+		#initialize_with(Faker::Name.name, Faker::Name.name)
+	end
+end

data/spec/lib/event_aggregator/aggregator_spec.rb

@@ -0,0 +1,202 @@
+require 'spec_helper'
+
+describe EventAggregator::Aggregator do
+	let(:listener)       { (Class.new { include EventAggregator::Listener }).new }
+	let(:listener_class) { Class.new { include EventAggregator::Listener }}
+	let(:message_type)   { Faker::Name.name }
+	let(:data)   { Faker::Name.name }
+
+	before(:each) do
+		EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+	end
+	describe "self.register" do
+		describe 'legal parameters' do
+			it 'registered at correct place' do
+				EventAggregator::Aggregator.register(listener, message_type)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to include(listener)
+			end
+
+			it 'should not be registered in wrong place' do
+				EventAggregator::Aggregator.register(listener, message_type)
+				EventAggregator::Aggregator.class_variable_get(:@@listeners).each do |e|
+					if e[0] == message_type
+						expect(e[1]).to include(listener)
+					else
+						expect(e[1]).to_not include(listener)
+					end
+				end
+			end
+		end
+		describe 'illegal parameters' do
+			it 'should not allow nil as message type' do
+				expect{EventAggregator::Aggregator.register(nil, message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			end
+			it 'should not allow non-listener to register' do
+				expect{EventAggregator::Aggregator.register(EventAggregator::Message.new("a","b"), message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.register("string", message_type)}.to_not                              change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.register(1, message_type)}.to_not                                     change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.register(2.0, message_type)}.to_not                                   change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			end
+		end
+	end
+
+	describe "self.unregister" do
+		describe 'legal parameters'  do
+			it 'should decrease count by 1' do
+				EventAggregator::Aggregator.register(listener, message_type)
+				expect{EventAggregator::Aggregator.unregister(listener, message_type)}.to change{EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type].length}.by(-1)
+			end
+			it 'should be remove from list' do
+				EventAggregator::Aggregator.register(listener, message_type)
+				EventAggregator::Aggregator.unregister(listener, message_type)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to_not include(listener)
+			end
+			it 'should keep listener in unrelated lists' do
+				message_type2 = message_type + " different"
+				
+				EventAggregator::Aggregator.register(listener, message_type)
+				EventAggregator::Aggregator.register(listener, message_type2)
+				
+				EventAggregator::Aggregator.unregister(listener, message_type)
+				
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include(listener)
+			end
+		end
+		describe 'unregitering nonregisterd listener' do
+			it 'should not change list' do
+				message_type1 = message_type + " different 1"
+				message_type2 = message_type + " different 2"
+				message_type3 = message_type + " different 3"
+				listener1 	  = listener_class.new
+				listener2 	  = listener_class.new
+				listener3 	  = listener_class.new
+
+				EventAggregator::Aggregator.register(listener1, message_type1)
+				EventAggregator::Aggregator.register(listener2, message_type2)
+				EventAggregator::Aggregator.register(listener3, message_type3)
+				
+				#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(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type1]).to include(listener1)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include(listener2)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type3]).to include(listener3)
+			end
+		end
+		describe 'unregitering listener from wrong message type' do
+			it 'should not change list' do
+				message_type2 = message_type + " different"
+
+				EventAggregator::Aggregator.register(listener, message_type)
+
+				expect{EventAggregator::Aggregator.unregister(listener, message_type2)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]}
+			end
+		end
+		describe 'unregitering non-listener class' do
+			it 'should not change register list' do
+				#Touching hash
+				EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]
+
+				expect{EventAggregator::Aggregator.unregister(EventAggregator::Message.new("a","b"), message_type)}.to_not change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.unregister("string", message_type)}.to_not                              change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.unregister(1, message_type)}.to_not                                     change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+				expect{EventAggregator::Aggregator.unregister(2.0, message_type)}.to_not                                   change{EventAggregator::Aggregator.class_variable_get(:@@listeners)}
+			end
+		end
+	end
+
+	describe "self.unregister_all" do
+		describe "unregistering listener registered to one message type" do
+			it "should unregister from list" do
+				EventAggregator::Aggregator.register(listener, message_type)
+
+				EventAggregator::Aggregator.unregister_all(listener)
+				
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to_not  include(listener)
+			end
+			it "should not unregister wrong listener" do
+				listener2 = listener_class.new
+				listener3 = listener_class.new
+				listener4 = listener_class.new
+
+				message_type2 = message_type + " different"
+				message_type3 = message_type + " different 2"
+
+				EventAggregator::Aggregator.register(listener, message_type)
+				EventAggregator::Aggregator.register(listener2, message_type)
+				EventAggregator::Aggregator.register(listener3, message_type2)
+				EventAggregator::Aggregator.register(listener4, message_type3)
+
+				
+				EventAggregator::Aggregator.unregister_all(listener)
+
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to include(listener2)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to include(listener3)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type3]).to include(listener4)
+			end
+		end
+		describe "unregistering listener registered for several message types" do
+			it "should unregister from all lists" do
+				EventAggregator::Aggregator.register(listener, message_type)
+				message_type2 = message_type + " different"
+				EventAggregator::Aggregator.register(listener, message_type2)
+
+				EventAggregator::Aggregator.unregister_all(listener)
+
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type]).to_not include(listener)
+				expect(EventAggregator::Aggregator.class_variable_get(:@@listeners)[message_type2]).to_not include(listener)
+			end
+		end
+	end
+
+	describe "self.message_publish" do
+		describe 'legal parameters' do
+			it 'should receive correct messages' do
+				EventAggregator::Aggregator.register(listener, message_type)
+				message = EventAggregator::Message.new(message_type, data)
+
+				expect(listener).to receive(:receive_message).with(message)
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+			it 'should not receive incorrect messages' do
+				message_type2 = message_type + " different"
+				
+				EventAggregator::Aggregator.register(listener, message_type)
+				message = EventAggregator::Message.new(message_type2, data)
+
+				expect(listener).to_not receive(:receive_message)
+
+				EventAggregator::Aggregator.message_publish(message)
+			end
+
+			it 'should send message to right listener' do
+				listener2 = listener_class.new
+				message_type2 = message_type + " different"
+
+				EventAggregator::Aggregator.register(listener, message_type)
+				EventAggregator::Aggregator.register(listener, message_type2)
+
+				message = EventAggregator::Message.new(message_type, data)
+
+				expect(listener).to receive(:receive_message).with(message)
+				expect(listener2).to_not receive(:receive_message)
+
+				EventAggregator::Aggregator.message_publish(message)
+			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(listener)}.to raise_error
+				expect{EventAggregator::Aggregator.message_publish()}.to         raise_error
+				expect{EventAggregator::Aggregator.message_publish(nil)}.to      raise_error
+			end
+		end
+	end
+end

data/spec/lib/event_aggregator/listener_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+
+# Public: Some ruby trickery to be able to test private methods
+#
+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
+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 }
+
+	before(:each) do
+		EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+		@message = EventAggregator::Message.new(message_type, data)
+	end
+	describe '.receive_message' do
+		describe 'legal parameters' do
+			it 'execute callback' do
+				#TODO: This is subject to refactor because the method is stroed in the module by a hack.
+				# This stuff should be moved to the aggregator, or somewhere else.
+				listener.class.publicize_methods do
+					listener.message_type_to_receive_add(message_type, lambda_method)
+
+					expect(lambda_method).to receive(:call)
+
+					listener.receive_message(@message)
+				end
+			end
+		end
+		describe 'illegal parameters' do
+			#This should not recieve illegal parameters.
+			it 'pending' do
+				pending "not implemented"
+			end
+		end
+	end
+
+	describe '.message_type_to_receive_add' do
+		describe 'legal parameters' do
+			it 'should register at aggregator' do
+				expect(EventAggregator::Aggregator).to receive(:register).with(listener, message_type)
+				
+				listener.class.publicize_methods do
+					listener.message_type_to_receive_add(message_type, lambda_method)
+				end
+			end
+			it 'pending' do
+				pending "not implemented"
+			end
+		end
+		describe 'illegal parameters' do
+			it 'not valid' do
+				expect{listener.message_type_to_receive_add(message_type, nil)}.to                raise_error
+				expect{listener.message_type_to_receive_add(message_type, 1)}.to                  raise_error
+				expect{listener.message_type_to_receive_add(message_type, "string")}.to           raise_error
+				expect{listener.message_type_to_receive_add(message_type, listener_class.new)}.to raise_error
+			end
+		end
+	end
+
+	describe '.message_type_to_receive_remove' do
+		describe 'legal parameters' do
+			it 'not recieve callbacks' do
+				listener.class.publicize_methods do
+					listener.message_type_to_receive_add(message_type, lambda_method)
+					listener.message_type_to_receive_remove(message_type)
+
+					expect(lambda_method).to_not receive(:call)
+
+					listener.receive_message(@message)
+				end
+			end
+		end
+		describe 'illegal parameters' do
+			it 'not registered reciever' do
+				pending "This will really likely be removed in next refactor"
+			end
+		end
+	end
+end

data/spec/lib/event_aggregator/message_spec.rb

@@ -0,0 +1,52 @@
+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 }) }
+
+    	before(:each) do
+			EventAggregator::Aggregator.class_variable_set :@@listener, Hash.new{|h, k| h[k] = []}
+			@listener_one = listener_class.new
+			@listener_two = listener_class.new
+			
+			EventAggregator::Aggregator.register(@listener_one, message_type)
+			EventAggregator::Aggregator.register(@listener_two, message_type+" different")
+		end
+
+    	it 'should be received by a correct subscribers' do
+    		message = EventAggregator::Message.new(message_type, data)
+    		expect(@listener_one).to receive(:receive_message).with(message)
+    		expect(@listener_two).to_not receive(:receive_message)
+
+    		message.publish
+    	end
+    	it 'should be published to the aggregator' do
+    		message = EventAggregator::Message.new(message_type, data)
+    		expect(EventAggregator::Aggregator).to receive(:message_publish).with(message)
+
+    		message.publish
+    	end
+	end
+
+	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
+		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
+			message = EventAggregator::Message.new(message_type, data)
+			
+			expect(message.message_type).to equal(message_type)
+			expect(message.data).to         equal(data)
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "rubygems"
+require "bundler/setup"
+require "factory_girl"
+require "faker"
+
+require "event_aggregator"
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = "random"
+
+
+  FactoryGirl.find_definitions
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: event_aggregator
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-09 00:00:00.000000000 Z
+date: 2013-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -43,6 +43,54 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: A simple Ruby event aggregator.
 email:
 - stephan.n.eriksen@gmail.com
@@ -51,7 +99,9 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
 - Gemfile
+- Guardfile
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -61,6 +111,11 @@ files:
 - lib/event_aggregator/listener.rb
 - lib/event_aggregator/message.rb
 - lib/event_aggregator/version.rb
+- spec/factories.rb
+- spec/lib/event_aggregator/aggregator_spec.rb
+- spec/lib/event_aggregator/listener_spec.rb
+- spec/lib/event_aggregator/message_spec.rb
+- spec/spec_helper.rb
 homepage: https://github.com/stephan-nordnes-eriksen/event_aggregator
 licenses:
 - MIT
@@ -86,4 +141,9 @@ rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Event aggregator for Ruby.
-test_files: []
+test_files:
+- spec/factories.rb
+- spec/lib/event_aggregator/aggregator_spec.rb
+- spec/lib/event_aggregator/listener_spec.rb
+- spec/lib/event_aggregator/message_spec.rb
+- spec/spec_helper.rb