eventception 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: caefa105ae332455e90b0834581a77c3c90cf44b
+  data.tar.gz: d4f3bf6f98004732be5c9edd84f20790f941319f
+SHA512:
+  metadata.gz: 88d5ca641b33ac10cc87ef059f1ec870aa2706a779a2b9fd91211cb421efa02b3819656b4a92393117ed6410686c633b982ce2ef2ab8ffaa4af27df5b97698a9
+  data.tar.gz: 20629ad6754729360fce12e56eaa0b13c01807b99add1f3a33ce3ecf9e91fc50cbcf4a176a5b79d1fddd5c8fc32aa0e289530bd729582141e94e39090d11cb90

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+# Change Log
+All notable changes to this project will be documented in this file. This change log follows the conventions of [keepachangelog.com](http://keepachangelog.com/).
+
+## [Unreleased]
+
+## 0.0.1 - 2017-07-13
+
+First release
+
+[Unreleased]: https://github.com/dcsg/eventception/compare/0.0.1...HEAD

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in eventception.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    eventception (0.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.3.0)
+    byebug (9.0.6)
+    coderay (1.1.1)
+    diff-lcs (1.3)
+    method_source (0.8.2)
+    parallel (1.11.2)
+    parser (2.4.0.0)
+      ast (~> 2.2)
+    powerpack (0.1.1)
+    pry (0.10.4)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    pry-byebug (3.4.2)
+      byebug (~> 9.0)
+      pry (~> 0.10)
+    rainbow (2.2.2)
+      rake
+    rake (12.0.0)
+    rspec (3.6.0)
+      rspec-core (~> 3.6.0)
+      rspec-expectations (~> 3.6.0)
+      rspec-mocks (~> 3.6.0)
+    rspec-core (3.6.0)
+      rspec-support (~> 3.6.0)
+    rspec-expectations (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-mocks (3.6.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.6.0)
+    rspec-support (3.6.0)
+    rubocop (0.49.1)
+      parallel (~> 1.10)
+      parser (>= 2.3.3.1, < 3.0)
+      powerpack (~> 0.1)
+      rainbow (>= 1.99.1, < 3.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
+    ruby-progressbar (1.8.1)
+    slop (3.6.0)
+    unicode-display_width (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.15)
+  eventception!
+  pry
+  pry-byebug
+  rake
+  rspec (~> 3.6)
+  rubocop
+
+BUNDLED WITH
+   1.15.1

data/README.md

@@ -0,0 +1,86 @@
+## Eventception
+
+[![Build Status](https://travis-ci.org/dcsg/eventception.svg?branch=master)](https://travis-ci.org/dcsg/eventception)
+
+Eventception is a lightweight and simple Ruby Event System inspired on [Symfony Event Dispatcher](https://symfony.com/doc/current/components/event_dispatcher.html).
+
+## How to Install
+
+Add the following to your `Gemfile`:
+```ruby
+gem 'eventception', '~> 0.0.1'
+```
+
+## How to use
+
+#### Events
+When an event is dispatched, it's identified by a unique name, which any number of listeners might be listening to. An Event instance is also created and passed to all of the listeners. As you'll see later, the Event object itself often contains data about the event being dispatched.
+
+#### The Dispatcher
+The dispatcher is the central object of the event dispatcher system.
+In general, a single dispatcher is created, which maintains a registry of listeners.
+When an event is dispatched via the dispatcher, it notifies all listeners registered with that event:
+
+```ruby
+require 'eventception'
+
+dispatcher = Eventception::Dispatcher.new
+```
+
+#### Adding Listeners
+
+```ruby
+require 'eventception'
+class TodoListener
+  def on_creation(event)
+    puts "created a new to-do with title: '#{event.todo.title}'"
+  end
+end
+
+listener = TodoListener.new
+dispatcher.add_listener(
+  event_name: 'todo.created',
+  listener: listener,
+  listener_method: 'on_creation'
+)
+```
+
+#### Creating and Dispatching an Event
+
+##### Creating the Event
+```ruby
+require 'eventception'
+class TodoCreatedEvent < Eventception::Event
+    NAME = 'todo.created'.freeze
+
+    attr_reader :todo
+
+    def initialize(todo)
+      @todo = todo
+    end
+end
+```
+
+##### Dispatching the Event
+```ruby
+class Todo
+    attr_reader :title
+
+    def initialize(title:)
+      @title = title
+    end
+end
+
+todo = Todo.new('My To-do')
+event = TodoCreatedEvent.new(todo)
+dispatcher.dispatch(TodoCreatedEvent::NAME, event)
+
+# STDOUT: created a new to-do with title: 'My To-do'
+```
+
+## Contributing
+
+## Contributors
+
+ * [Daniel Gomes](https://github.com/dcsg)
+ * [Ivo Anjo](https://github.com/ivoanjo)

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :test, :development
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task :spec
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new
+
+task default: %i[rubocop spec]

data/eventception.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'eventception'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'eventception'
+  spec.version     = Eventception::VERSION
+  spec.authors     = ['Daniel Gomes', 'Ivo Anjo']
+  spec.email       = ['danielcesargomes@gmail.com', 'ivo.anjo@ist.utl.pt']
+  spec.homepage    = 'https://github.com/dcsg/eventception'
+  spec.summary     = 'Eventception - a lightweight and simple Ruby Event System.'
+  spec.description = 'A lightweight and simple Ruby Event System inspired on Symfony Event Dispatcher.'
+  spec.license     = 'MIT'
+
+  spec.files         = Dir['**/*'].keep_if { |file| File.file?(file) }
+  spec.test_files    = Dir['spec/**/*']
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 2.2.0'
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rspec', '~> 3.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'pry-byebug' unless RUBY_PLATFORM == 'java'
+  spec.add_development_dependency 'pry-debugger-jruby' if RUBY_PLATFORM == 'java'
+end

data/examples/todo_list/run.rb

@@ -0,0 +1,19 @@
+require 'eventception'
+require_relative 'todo_created_event'
+require_relative 'todo_listener'
+require_relative 'todo'
+
+# configure the event dispatcher and register the listener
+dispatcher = Eventception::Dispatcher.new
+dispatcher.add_listener(
+  event_name: TodoList::TodoCreatedEvent::NAME,
+  listener: TodoList::TodoListener.new,
+  listener_method: 'on_creation',
+)
+
+# create a new to-do and dispatch the event
+todo = TodoList::Todo.new(title: 'Emit and Event', description: 'Event emitted')
+event = TodoList::TodoCreatedEvent.new(todo)
+dispatcher.dispatch(event_name: TodoList::TodoCreatedEvent::NAME, event: event)
+
+# STDOUT: "created a new to-do with title: 'Emit and Event' and description: 'Event emitted'"

data/examples/todo_list/todo.rb

@@ -0,0 +1,11 @@
+module TodoList
+  class Todo
+    attr_reader :title
+    attr_reader :description
+
+    def initialize(title:, description:)
+      @title = title
+      @description = description
+    end
+  end
+end

data/examples/todo_list/todo_created_event.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'eventception'
+
+module TodoList
+  class TodoCreatedEvent < Eventception::Event
+    NAME = 'todo.created'.freeze
+
+    attr_reader :todo
+
+    def initialize(todo)
+      @todo = todo
+    end
+  end
+end

data/examples/todo_list/todo_listener.rb

@@ -0,0 +1,7 @@
+module TodoList
+  class TodoListener
+    def on_creation(event)
+      puts "created a new to-do with title: '#{event.todo.title}' and description: '#{event.todo.description}'"
+    end
+  end
+end

data/lib/eventception/base_subscriber.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Eventception
+  class BaseSubscriber
+    def subscribed_events
+      raise NoMethodError, 'Method needs to be implement. Consider extend this class.'
+    end
+  end
+end

data/lib/eventception/dispatcher.rb

@@ -0,0 +1,188 @@
+require 'eventception/priority_listeners'
+require 'eventception/listener_handler'
+
+module Eventception
+  class Dispatcher
+    private
+
+    def event_listeners
+      @event_listeners ||= Hash.new { |hash, key|
+        priority_listeners_hash = Hash.new { |priority_hash, priority_level|
+          priority_hash[priority_level] = PriorityListeners.new(priority: priority_level)
+        }
+
+        hash[key] = priority_listeners_hash
+      }
+    end
+
+    def sorted
+      @sorted ||= Hash.new { |hash, key| hash[key] = {} }
+    end
+
+    public
+
+    # Dispatches an event to all registered listeners.
+    #
+    # == Parameters:
+    # event_name::
+    #   The name of the event to dispatch. The name of
+    #   the event is the name of the method that is
+    #   invoked on listeners.
+    # event::
+    #   The event to pass to the event handlers/listeners
+    #   If not supplied, an empty Event instance is created.
+    #
+    # == Returns:
+    #   The Event.
+    #
+    def dispatch(event_name:, event: Eventception::Event.new)
+      if listeners_for?(event_name: event_name)
+        do_dispatch(listeners: listeners_for(event_name: event_name), event: event)
+      end
+
+      event
+    end
+
+    # Gets all listeners sorted by descending priority.
+    #
+    # == Returns:
+    #   All event listeners sorted by event_name and descending priority.
+    #
+    def listeners
+      return [] if event_listeners.empty?
+
+      event_listeners.each_key do |event_name|
+        sort_listeners(event_name) if sorted[event_name].empty?
+      end
+
+      sorted
+    end
+
+    # Checks whether are any registered listeners.
+    #
+    # == Returns:
+    #   Boolean
+    #
+    def listeners?
+      listeners.any?
+    end
+
+    # Gets all listeners for the specific event sorted by descending priority.
+    #
+    # == Returns:
+    #   The event listeners for the specific event sorted by descending priority.
+    #
+    def listeners_for(event_name:)
+      return [] if event_listeners[event_name].empty?
+
+      sort_listeners(event_name) if sorted[event_name].empty?
+
+      sorted[event_name]
+    end
+
+    # Checks whether are any registered listeners for the specific event.
+    #
+    # == Returns:
+    #   Boolean
+    #
+    def listeners_for?(event_name:)
+      event_listeners[event_name].any?
+    end
+
+    # Add an event listener that listens to the specified event.
+    #
+    # == Parameters:
+    # event_name::
+    #   The event to listen on
+    # listener::
+    #   The listener
+    # priority::
+    #   The higher this value, the earlier an event listener will be triggered in the chain (defaults to 0)
+    #
+    def add_listener(event_name:, listener:, listener_method:, priority: 0)
+      event_listeners[event_name][priority] << ListenerHandler.new(listener, listener_method)
+      sorted.delete(event_name)
+
+      nil
+    end
+
+    def remove_listener(event_name:, listener:, listener_method:)
+      return unless listeners_for?(event_name: event_name)
+
+      listener_for_event = event_listeners.fetch(event_name)
+
+      listener_for_event.each do |priority, priority_listeners|
+        sorted.delete(event_name) if priority_listeners.delete(ListenerHandler.new(listener, listener_method))
+
+        listener_for_event.delete(priority) if priority_listeners.empty?
+      end
+
+      event_listeners.delete(event_name) if listener_for_event.empty?
+    end
+
+    # Add an event subscriber.
+    #
+    # The subscriber is asked for all the events he is interested in and added as a listener for these events.
+    #
+    # == Parameters:
+    # subscriber::
+    #   The subscriber
+    #
+    def add_subscriber(subscriber:)
+      subscriber.subscribed_events.each do |event_subscribed|
+        add_listener(
+          event_name: event_subscribed.fetch(:event_name),
+          listener: subscriber,
+          listener_method: event_subscribed.fetch(:listener_method),
+          priority: event_subscribed[:priority] || 0,
+        )
+      end
+    end
+
+    def remove_subscriber(subscriber:)
+      subscriber.subscribed_events.each do |event_subscribed|
+        remove_listener(
+          event_name: event_subscribed.fetch(:event_name),
+          listener: subscriber,
+          listener_method: event_subscribed.fetch(:listener_method),
+        )
+      end
+    end
+
+    protected
+
+    # Triggers the listeners of an event.
+    #
+    # This method can be overridden to add functionality that is executed for each listener.
+    #
+    # == Parameters:
+    # listeners::
+    #   The event listeners
+    # event::
+    #   The event
+    #
+    def do_dispatch(listeners:, event:)
+      listeners.each do |_priority, priority_listeners|
+        priority_listeners.each do |listener_handler|
+          return nil if event.propagation_stopped?
+
+          listener_handler.call(event)
+        end
+      end
+
+      nil
+    end
+
+    private
+
+    # Sorts the internal list of listeners for the given event by priority.
+    #
+    # == Parameters:
+    # event_name::
+    #   The event name
+    #
+    def sort_listeners(event_name)
+      sorted[event_name] = event_listeners[event_name].sort_by { |key, _| -key }.to_h
+    end
+  end
+end

data/lib/eventception/event.rb

@@ -0,0 +1,19 @@
+module Eventception
+  class Event
+    private
+
+    def propagation_stopped
+      @propagation_stopped ||= false
+    end
+
+    public
+
+    def propagation_stopped?
+      propagation_stopped
+    end
+
+    def stop_propagation
+      @propagation_stopped = true
+    end
+  end
+end

data/lib/eventception/listener_handler.rb

@@ -0,0 +1,23 @@
+module Eventception
+  class ListenerHandler
+    attr_reader :listener
+    attr_reader :method
+
+    def initialize(listener, method)
+      @listener = listener
+      @method = method
+    end
+
+    def call(event)
+      listener.public_send(method, event)
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def eql?(other)
+      listener == other.listener && method == other.method
+    end
+  end
+end

data/lib/eventception/priority_listeners.rb

@@ -0,0 +1,46 @@
+module Eventception
+  class PriorityListeners
+    include Enumerable
+
+    private
+
+    attr_reader :listeners
+
+    public
+
+    attr_reader :priority
+
+    def initialize(priority:)
+      @priority = priority
+      @listeners = []
+    end
+
+    def <<(listener)
+      listeners << listener
+    end
+
+    def <=>(other)
+      other.priority <=> priority
+    end
+
+    def delete(listener)
+      listeners.delete(listener)
+    end
+
+    def each(&block)
+      listeners.each(&block)
+    end
+
+    def size
+      listeners.size
+    end
+
+    def count
+      size
+    end
+
+    def empty?
+      listeners.empty?
+    end
+  end
+end

data/lib/eventception/version.rb

@@ -0,0 +1,3 @@
+module Eventception
+  VERSION = '0.0.1'.freeze
+end

data/lib/eventception.rb

@@ -0,0 +1,5 @@
+require 'eventception/event'
+require 'eventception/listener_handler'
+require 'eventception/dispatcher'
+require 'eventception/base_subscriber'
+require 'eventception/version'

data/spec/eventception/dispatcher_spec.rb

@@ -0,0 +1,211 @@
+require 'spec_helper'
+require 'support/listener'
+require 'support/subscriber'
+require 'support/test_event'
+require 'eventception/listener_handler'
+
+describe Eventception::Dispatcher do
+  subject(:dispatcher) { described_class.new }
+
+  let(:listener) { Eventception::Support::Listener.new }
+  let(:listener_method) { 'on_before' }
+  let(:subscriber) { Eventception::Support::Subscriber.new }
+  let(:event_name) { :on_after }
+  let(:priority) { 0 }
+
+  describe '#listeners?' do
+    context 'when no event_name is provided' do
+      context 'and does not have any listeners associated' do
+        it do
+          expect(dispatcher.listeners?).to be false
+        end
+      end
+
+      context 'and has one or more listeners associated' do
+        before do
+          dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+        end
+
+        it do
+          expect(dispatcher.listeners?).to be true
+        end
+      end
+    end
+
+    context 'when an event_name is provided' do
+      context 'and does not have any listener associated' do
+        it do
+          expect(dispatcher.listeners_for?(event_name: event_name)).to be false
+        end
+      end
+
+      context 'and has one or more listeners associated' do
+        before do
+          dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+        end
+
+        it do
+          expect(dispatcher.listeners_for?(event_name: event_name)).to be true
+        end
+
+        context 'when a different event_name is provided without any listener associated' do
+          it do
+            expect(dispatcher.listeners_for?(event_name: :invalid)).to be false
+          end
+        end
+      end
+    end
+  end
+
+  describe '#add_listener' do
+    context 'when no priority is provided' do
+      before do
+        dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+      end
+
+      it 'adds a new listener to the event_name with 0 priority' do
+        listeners = dispatcher.listeners_for(event_name: event_name)
+
+        expect(listeners[priority].count).to eq 1
+        expect(listeners[priority].first.listener).to eq listener
+        expect(listeners[priority].first.method).to eq listener_method
+      end
+    end
+
+    context 'when priority of 10 is provided' do
+      let(:priority) { 10 }
+
+      before do
+        dispatcher.add_listener(
+          event_name: event_name,
+          listener: listener,
+          listener_method: listener_method,
+          priority: priority,
+        )
+      end
+
+      it 'adds a new listener to the event_name with a different priority' do
+        listeners = dispatcher.listeners_for(event_name: event_name)
+
+        expect(listeners[priority].count).to eq 1
+        expect(listeners[priority].first.listener).to eq listener
+        expect(listeners[priority].first.method).to eq listener_method
+      end
+    end
+  end
+
+  describe '#listeners' do
+    context 'when listeners exist' do
+      before do
+        dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+      end
+
+      context 'when no event_name is provided' do
+        it 'adds a new listener to the event_name with 0 priority' do
+          listeners = dispatcher.listeners
+
+          expect(listeners.size).to eq 1
+        end
+      end
+
+      context 'when an event_name is provided' do
+        it 'adds a new listener to the event_name with 10 priority' do
+          listeners = dispatcher.listeners_for(event_name: event_name)
+
+          expect(listeners[priority].count).to eq 1
+          expect(listeners[priority].first.listener).to eq listener
+          expect(listeners[priority].first.method).to eq listener_method
+        end
+      end
+    end
+  end
+
+  describe '#remove_listener' do
+    let(:listener_method2) { 'on_after' }
+
+    context 'when two listeners exist for the same event_name' do
+      before do
+        dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+        dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method2)
+      end
+
+      it 'has two listeners' do
+        expect(dispatcher.listeners_for?(event_name: event_name)).to be true
+        expect(dispatcher.listeners_for(event_name: event_name)[priority].size).to eq 2
+      end
+
+      context 'and one of the listeners is removed' do
+        it 'has only one listener' do
+          dispatcher.remove_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+          expect(dispatcher.listeners_for(event_name: event_name)[priority].size).to eq 1
+        end
+      end
+
+      context 'and both listeners are removed' do
+        it 'has zero listeners' do
+          dispatcher.remove_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+          dispatcher.remove_listener(event_name: event_name, listener: listener, listener_method: listener_method2)
+          expect(dispatcher.listeners_for?(event_name: event_name)).to be false
+          expect(dispatcher.listeners_for(event_name: event_name).size).to eq 0
+        end
+      end
+    end
+  end
+
+  describe '#add_subscriber' do
+    before do
+      dispatcher.add_subscriber(subscriber: subscriber)
+    end
+
+    it 'subscribes two events' do
+      listeners = dispatcher.listeners
+      expect(listeners.size).to eq 2
+      listeners.each do |_event_name, listener|
+        expect(listener[priority].size).to eq 1
+      end
+    end
+  end
+
+  describe '#remove_subscriber' do
+    before do
+      dispatcher.add_subscriber(subscriber: subscriber)
+    end
+
+    it 'removes the subscriber listeners' do
+      expect(dispatcher.listeners.size).to eq 2
+      dispatcher.remove_subscriber(subscriber: subscriber)
+      expect(dispatcher.listeners?).to be false
+    end
+  end
+
+  describe '#dispatch' do
+    context 'when using subscribers' do
+      before do
+        dispatcher.add_subscriber(subscriber: subscriber)
+      end
+
+      it 'calls the subscriber methods' do
+        expect(subscriber).to receive('on_before').and_call_original
+        expect(subscriber).to receive('on_after').and_call_original
+
+        expect {
+          dispatcher.dispatch(event_name: Eventception::Support::TestEvent::BEFORE)
+        }.to output(/on before, propagation stopped/).to_stdout
+        expect {
+          dispatcher.dispatch(event_name: Eventception::Support::TestEvent::AFTER)
+        }.to output(/on after, propagation stopped/).to_stdout
+      end
+    end
+
+    context 'when using listeners' do
+      before do
+        dispatcher.add_listener(event_name: event_name, listener: listener, listener_method: listener_method)
+      end
+
+      it 'executes the listener method' do
+        expect(listener).to receive(listener_method).and_call_original
+        expect { dispatcher.dispatch(event_name: event_name) }.to output(/before/).to_stdout
+      end
+    end
+  end
+end

data/spec/eventception/listener_handler_spec.rb

@@ -0,0 +1,75 @@
+require 'eventception'
+require 'spec_helper'
+require 'support/listener'
+require 'support/subscriber'
+require 'support/test_event'
+require 'support/listener'
+
+describe Eventception::ListenerHandler do
+  subject(:event_handler) { described_class.new(listener, listener_method) }
+
+  let(:listener_method) { 'on_before' }
+  let(:listener_method2) { 'on_after' }
+  let(:listener) { Eventception::Support::Listener.new }
+  let(:listener2) { Eventception::Support::Listener.new }
+
+  describe '#call' do
+    it 'executes the listener method' do
+      expect(listener).to receive(listener_method)
+
+      event_handler.call(Eventception::Event.new)
+    end
+  end
+
+  describe '#==' do
+    context 'when the two event handlers have the same listener and method' do
+      let(:event_handler2) { described_class.new(listener, listener_method) }
+
+      it do
+        expect(event_handler == event_handler2).to be true
+      end
+    end
+
+    context 'when the two event handlers have different listener and same method' do
+      let(:event_handler2) { described_class.new(listener2, listener_method) }
+
+      it do
+        expect(event_handler == event_handler2).to be false
+      end
+    end
+
+    context 'when the two event handlers have same listener but different method' do
+      let(:event_handler2) { described_class.new(listener, listener_method2) }
+
+      it do
+        expect(event_handler == event_handler2).to be false
+      end
+    end
+  end
+
+  describe '#eql?' do
+    context 'when the two event handlers have the same listener and method' do
+      let(:event_handler2) { described_class.new(listener, listener_method) }
+
+      it do
+        expect(event_handler.eql?(event_handler2)).to be true
+      end
+    end
+
+    context 'when the two event handlers have different listener and same method' do
+      let(:event_handler2) { described_class.new(listener2, listener_method) }
+
+      it do
+        expect(event_handler.eql?(event_handler2)).to be false
+      end
+    end
+
+    context 'when the two event handlers have same listener but different method' do
+      let(:event_handler2) { described_class.new(listener, listener_method2) }
+
+      it do
+        expect(event_handler.eql?(event_handler2)).to be false
+      end
+    end
+  end
+end

data/spec/examples/todo_list_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe 'TodoList example' do
+  it 'runs without error' do
+    load File.expand_path('../../../examples/todo_list/run.rb', Pathname.new(__FILE__).realpath)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'eventception'
+
+RSpec.configure do |config|
+end

data/spec/support/listener.rb

@@ -0,0 +1,13 @@
+module Eventception
+  module Support
+    class Listener
+      def on_before(_event)
+        puts 'before'
+      end
+
+      def on_after(_event)
+        puts 'after'
+      end
+    end
+  end
+end

data/spec/support/subscriber.rb

@@ -0,0 +1,23 @@
+require 'eventception'
+require_relative 'test_event'
+
+module Eventception
+  module Support
+    class Subscriber < Eventception::BaseSubscriber
+      def subscribed_events
+        [
+          { event_name: TestEvent::BEFORE, listener_method: 'on_before', priority: 0 },
+          { event_name: TestEvent::AFTER, listener_method: 'on_after' },
+        ]
+      end
+
+      def on_before(event)
+        puts "on before, propagation stopped? #{event.propagation_stopped?}"
+      end
+
+      def on_after(event)
+        puts "on after, propagation stopped? #{event.propagation_stopped?}"
+      end
+    end
+  end
+end

data/spec/support/test_event.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'eventception'
+
+module Eventception
+  module Support
+    class TestEvent < Eventception::Event
+      BEFORE = 'test.before'
+      AFTER = 'test.after'
+    end
+  end
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: eventception
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Gomes
+- Ivo Anjo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A lightweight and simple Ruby Event System inspired on Symfony Event
+  Dispatcher.
+email:
+- danielcesargomes@gmail.com
+- ivo.anjo@ist.utl.pt
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- eventception.gemspec
+- examples/todo_list/run.rb
+- examples/todo_list/todo.rb
+- examples/todo_list/todo_created_event.rb
+- examples/todo_list/todo_listener.rb
+- lib/eventception.rb
+- lib/eventception/base_subscriber.rb
+- lib/eventception/dispatcher.rb
+- lib/eventception/event.rb
+- lib/eventception/listener_handler.rb
+- lib/eventception/priority_listeners.rb
+- lib/eventception/version.rb
+- pkg/eventception-0.0.1.gem
+- spec/eventception/dispatcher_spec.rb
+- spec/eventception/listener_handler_spec.rb
+- spec/examples/todo_list_spec.rb
+- spec/spec_helper.rb
+- spec/support/listener.rb
+- spec/support/subscriber.rb
+- spec/support/test_event.rb
+homepage: https://github.com/dcsg/eventception
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Eventception - a lightweight and simple Ruby Event System.
+test_files:
+- spec/eventception/dispatcher_spec.rb
+- spec/eventception/listener_handler_spec.rb
+- spec/examples/todo_list_spec.rb
+- spec/spec_helper.rb
+- spec/support/listener.rb
+- spec/support/subscriber.rb
+- spec/support/test_event.rb