dry-events 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8df0a07c20aa79e2b47d1f8eda583936b6109e09e5307826593e1e8f792c7675
+  data.tar.gz: c99dfee0bf7614b62fc70d8ea809d419fcf8fb01400149f83610fd9a9e586019
+SHA512:
+  metadata.gz: 3060f0fe13e7cb9199e81e82c82be67bca90a547a0750b094f0afcdcb193aba0866c3c3a7af2e81923dec194bc1828d9fc4ae7fa099c0c87952cba68f77afff2
+  data.tar.gz: 33845156cc553098260f562001b3fa0d2aa711c95ee8d056c0f1362eccda69e8b8954040bf0b542b47826a81b813d1a338ced05712e10e36a8770fad4eef867f

data/.gitignore

@@ -0,0 +1,9 @@
+.DS_Store
+coverage
+/.bundle
+vendor/bundle
+bin/
+tmp/
+.idea/
+Gemfile.lock
+spec/test_logs/*.log

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--require spec_helper
+--order random

data/.travis.yml

@@ -0,0 +1,22 @@
+language: ruby
+cache: bundler
+bundler_args: --without benchmarks console tools
+script: "bundle exec rake ci"
+before_install: gem update --system
+after_success:
+  - '[ "${TRAVIS_JOB_NUMBER#*.}" = "1" ] && [ "$TRAVIS_BRANCH" = "master" ] && bundle exec codeclimate-test-reporter'
+rvm:
+  - 2.5.0
+  - 2.4.3
+  - 2.3.6
+  - jruby-9.1.9.0
+env:
+  global:
+    - COVERAGE='true'
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/19098b4253a72c9796db
+    on_success: change
+    on_failure: always
+    on_start: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# v0.1.0 to-be-released
+
+First public release

data/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Issue Guidelines
+
+## Reporting bugs
+
+If you found a bug, report an issue and describe what's the expected behavior versus what actually happens. If the bug causes a crash, attach a full backtrace. If possible, a reproduction script showing the problem is highly appreciated.
+
+## Reporting feature requests
+
+Report a feature request **only after discussing it first on [discuss.dry-rb.org](https://discuss.dry-rb.org)** where it was accepted. Please provide a concise description of the feature, don't link to a discussion thread, and instead summarize what was discussed.
+
+## Reporting questions, support requests, ideas, concerns etc.
+
+**PLEASE DON'T** - use [discuss.dry-rb.org](http://discuss.dry-rb.org) instead.
+
+# Pull Request Guidelines
+
+A Pull Request will only be accepted if it addresses a specific issue that was reported previously, or fixes typos, mistakes in documentation etc.
+
+Other requirements:
+
+1) Do not open a pull request if you can't provide tests along with it. If you have problems writing tests, ask for help in the related issue.
+2) Follow the style conventions of the surrounding code. In most cases, this is standard ruby style.
+3) Add API documentation if it's a new feature
+4) Update API documentation if it changes an existing feature
+5) Bonus points for sending a PR to [github.com/dry-rb/dry-rb.org](github.com/dry-rb/dry-rb.org) which updates user documentation and guides
+
+# Asking for help
+
+If these guidelines aren't helpful, and you're stuck, please post a message on [discuss.dry-rb.org](https://discuss.dry-rb.org).

data/Gemfile

@@ -0,0 +1,13 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :test do
+  gem 'rack'
+  gem 'simplecov', platform: :mri, require: false
+  gem 'codeclimate-test-reporter', require: false
+end
+
+group :tools do
+  gem 'byebug', platform: :mri
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 dry-rb team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,26 @@
+[gem]: https://rubygems.org/gems/dry-events
+[travis]: https://travis-ci.org/dry-rb/dry-events
+[gemnasium]: https://gemnasium.com/dry-rb/dry-events
+[codeclimate]: https://codeclimate.com/github/dry-rb/dry-events
+[coveralls]: https://coveralls.io/r/dry-rb/dry-events
+[inchpages]: http://inch-ci.org/github/dry-rb/dry-events
+
+# dry-events [![Join the chat at https://gitter.im/dry-rb/chat](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/dry-rb/chat)
+
+[![Gem Version](https://badge.fury.io/rb/dry-events.svg)][gem]
+[![Build Status](https://travis-ci.org/dry-rb/dry-events.svg?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/dry-rb/dry-events.svg)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/dry-rb/dry-events/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/dry-rb/dry-events/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/dry-rb/dry-events.svg?branch=master)][inchpages]
+
+Standalone pub/sub system.
+
+## Synopsis
+
+``` ruby
+```
+
+## License
+
+See `LICENSE` file.

data/Rakefile

@@ -0,0 +1,15 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+task default: :spec
+
+desc 'Run all specs in spec directory'
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run CI tasks"
+task ci: [:spec]

data/dry-events.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+require File.expand_path('../lib/dry/events/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'dry-events'
+  spec.version       = Dry::Events::VERSION
+  spec.authors       = ['Piotr Solnica']
+  spec.email         = ['piotr.solnica+oss@gmail.com']
+  spec.summary       = 'Pub/sub system'
+  spec.homepage      = 'https://github.com/dry-rb/dry-events'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'concurrent-ruby', '~> 1.0'
+  spec.add_runtime_dependency 'dry-core', '~> 0.4'
+  spec.add_runtime_dependency 'dry-equalizer', '~> 0.2'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/lib/dry-events.rb

@@ -0,0 +1 @@
+require 'dry/events'

data/lib/dry/events.rb

@@ -0,0 +1 @@
+require 'dry/events/publisher'

data/lib/dry/events/bus.rb

@@ -0,0 +1,82 @@
+require 'dry/events/constants'
+
+module Dry
+  module Events
+    # Event bus
+    #
+    # An event bus stores listeners (callbacks) and events
+    #
+    # @api private
+    class Bus
+      # @!attribute [r] events
+      #   @return [Hash] A hash with events registered within a bus
+      attr_reader :events
+
+      # @!attribute [r] listeners
+      #   @return [Hash] A hash with event listeners registered within a bus
+      attr_reader :listeners
+
+      # Initialize a new event bus
+      #
+      # @param [Symbol] id The bus identifier
+      # @param [Hash] events A hash with events
+      # @param [Hash] listeners A hash with listeners
+      #
+      # @api private
+      def initialize(events: EMPTY_HASH, listeners: LISTENERS_HASH.dup)
+        @listeners = listeners
+        @events = events
+      end
+
+      # @api private
+      def process(event_id, payload, &block)
+        listeners[event_id].each do |(listener, query)|
+          event = events[event_id].payload(payload)
+
+          if event.trigger?(query)
+            yield(event, listener)
+          end
+        end
+      end
+
+      # @api private
+      def publish(event_id, payload)
+        process(event_id, payload) do |event, listener|
+          listener.(event)
+        end
+      end
+
+      # @api private
+      def attach(listener, query)
+        events.each do |id, event|
+          meth = event.listener_method
+
+          if listener.respond_to?(meth)
+            listeners[id] << [listener.method(meth), query]
+          end
+        end
+      end
+
+      # @api private
+      def detach(listener)
+        listeners.each do |id, memo|
+          memo.each do |tuple|
+            current_listener, _ = tuple
+            listeners[id].delete(tuple) if current_listener.receiver.equal?(listener)
+          end
+        end
+      end
+
+      # @api private
+      def subscribe(event_id, query, &block)
+        listeners[event_id] << [block, query]
+        self
+      end
+
+      # @api private
+      def subscribed?(listener)
+        listeners.values.any? { |value| value.any? { |(block, _)| block.equal?(listener) } }
+      end
+    end
+  end
+end

data/lib/dry/events/constants.rb

@@ -0,0 +1,10 @@
+require 'concurrent/map'
+require 'dry/core/constants'
+
+module Dry
+  module Events
+    include Dry::Core::Constants
+
+    LISTENERS_HASH = Concurrent::Map.new { |h, k| h[k] = [] }
+  end
+end

data/lib/dry/events/event.rb

@@ -0,0 +1,81 @@
+require 'dry/equalizer'
+require 'dry/events/constants'
+
+module Dry
+  module Events
+    # Event object
+    #
+    # @api public
+    class Event
+      include Dry::Equalizer(:id, :payload)
+
+      DOT = '.'.freeze
+      UNDERSCORE = '_'.freeze
+
+      # @!attribute [r] id
+      #   @return [Symbol] The event identifier
+      attr_reader :id
+
+      # Initialize a new event
+      #
+      # @param [Symbol] id The event identifier
+      # @param [Hash] payload Optional payload
+      #
+      # @return [Event]
+      #
+      # @api private
+      def initialize(id, payload = EMPTY_HASH)
+        @id = id
+        @payload = payload
+      end
+
+      # Get data from the payload
+      #
+      # @param [String,Symbol] name
+      #
+      # @api public
+      def [](name)
+        @payload.fetch(name)
+      end
+
+      # Coerce an event to a hash
+      #
+      # @return [Hash]
+      #
+      # @api public
+      def to_h
+        @payload
+      end
+      alias_method :to_hash, :to_h
+
+      # Get or set a payload
+      #
+      # @overload
+      #   @return [Hash] payload
+      #
+      # @overload payload(data)
+      #   @param [Hash] data A new payload
+      #   @return [Event] A copy of the event with the provided payload
+      #
+      # @api public
+      def payload(data = nil)
+        if data
+          self.class.new(id, @payload.merge(data))
+        else
+          @payload
+        end
+      end
+
+      # @api private
+      def trigger?(query)
+        query.empty? || query.all? { |key, value| payload[key] == value }
+      end
+
+      # @api private
+      def listener_method
+        @listener_method ||= :"on_#{id.to_s.gsub(DOT, UNDERSCORE)}"
+      end
+    end
+  end
+end
+

data/lib/dry/events/listener.rb

@@ -0,0 +1,57 @@
+require 'dry/equalizer'
+require 'dry/events/publisher'
+
+module Dry
+  module Events
+    # Extension for objects that can listen to events
+    #
+    # @example
+    #   class AppEvents
+    #     include Dry::Events::Publisher[:app]
+    #
+    #     register_event("users.created")
+    #   end
+
+    #   class MyListener
+    #     include Dry::Events::Listener[:app]
+    #
+    #     subscribe("users.created") do |event|
+    #       # do something
+    #     end
+    #   end
+    #
+    # @api public
+    class Listener < Module
+      include Dry::Equalizer(:id)
+
+      # @!attribute [r] :id
+      #   @return [Symbol,String] The publisher identifier
+      #   @api private
+      attr_reader :id
+
+      # Create a listener extension for a specific publisher
+      #
+      # @return [Module]
+      #
+      # @api public
+      def self.[](id)
+        new(id)
+      end
+
+      # @api private
+      def initialize(id)
+        @id = id
+
+        define_method(:subscribe) do |event_id, query = EMPTY_HASH, &block|
+          Publisher.registry[id].subscribe(event_id, query, &block)
+        end
+      end
+
+      # @api private
+      def included(klass)
+        klass.extend(self)
+        super
+      end
+    end
+  end
+end

data/lib/dry/events/publisher.rb

@@ -0,0 +1,242 @@
+require 'concurrent/map'
+
+require 'dry/core/class_attributes'
+
+require 'dry/events/constants'
+require 'dry/events/event'
+require 'dry/events/bus'
+
+module Dry
+  module Events
+    # Exception raised when the same publisher is registered more than once
+    #
+    # @api public
+    PublisherAlreadyRegisteredError = Class.new(StandardError) do
+      # @api private
+      def initialize(id)
+        super("publisher with id #{id.inspect} already registered as: #{Publisher.registry[id]}")
+      end
+    end
+
+    # Extension used for classes that can publish events
+    #
+    # @example
+    #   class AppEvents
+    #     include Dry::Events::Publisher[:app]
+    #
+    #     register_event('users.created')
+    #   end
+    #
+    #   class CreateUser
+    #     attr_reader :events
+    #
+    #     def initialize(events)
+    #       @events = events
+    #     end
+    #
+    #     def call(user)
+    #       # do your thing
+    #       events.publish('users.created', user: user, time: Time.now)
+    #     end
+    #   end
+    #
+    #   app_events = AppEvents.new
+    #   create_user = CreateUser.new(app_events)
+    #
+    #   # this will publish "users.created" event with its payload
+    #   create_user.call(name: "Jane")
+    #
+    # @api public
+    class Publisher < Module
+      include Dry::Equalizer(:id)
+
+      # Internal publisher registry, which is used to identify them globally
+      #
+      # This allows us to have listener classes that can subscribe to events
+      # without having access to instances of publishers yet.
+      #
+      # @api private
+      def self.registry
+        @__registry__ ||= Concurrent::Map.new
+      end
+
+      # @!attribute [r] :id
+      #   @return [Symbol,String] the publisher identifier
+      #   @api private
+      attr_reader :id
+
+      # Create a publisher extension with the provided identifier
+      #
+      # @param [Symbol,String] id The identifier
+      #
+      # @return [Publisher]
+      #
+      # @raise PublisherAlreadyRegisteredError
+      #
+      # @api public
+      def self.[](id)
+        raise PublisherAlreadyRegisteredError.new(id) if registry.key?(id)
+        new(id)
+      end
+
+      # @api private
+      def initialize(id)
+        @id = id
+      end
+
+      # Hook for inclusions/extensions
+      #
+      # It registers the publisher class under global registry using the id
+      #
+      # @api private
+      def included(klass)
+        klass.extend(ClassMethods)
+        klass.include(InstanceMethods)
+
+        self.class.registry[id] = klass
+
+        super
+      end
+
+      # Class interface for publisher classes
+      #
+      # @api public
+      module ClassMethods
+        # Register an event
+        #
+        # @param [String] event_id The event identifier
+        # @param [Hash] payload Optional default payload
+        #
+        # @api public
+        def register_event(event_id, payload = EMPTY_HASH)
+          events[event_id] = Event.new(event_id, payload)
+          self
+        end
+
+        # Subscribe to an event
+        #
+        # @param [Symbol,String] event_id The event identifier
+        # @param [Hash] query An optional query for conditional listeners
+        #
+        # @return [Class] publisher class
+        #
+        # @api public
+        def subscribe(event_id, query = EMPTY_HASH, &block)
+          listeners[event_id] << [block, query]
+          self
+        end
+
+        # Sets up event bus for publisher instances
+        #
+        # @return [Bus]
+        #
+        # @api private
+        def new_bus
+          Bus.new(events: events.dup, listeners: listeners.dup)
+        end
+
+        # Global registry with events
+        #
+        # @api private
+        def events
+          @__events__ ||= Concurrent::Map.new
+        end
+
+        # Global registry with listeners
+        #
+        # @api private
+        def listeners
+          @__listeners__ ||= LISTENERS_HASH.dup
+        end
+      end
+
+      # Instance interface for publishers
+      #
+      # @api public
+      module InstanceMethods
+        # Register a new event type at instance level
+        #
+        # @param [Symbol,String] event_id The event identifier
+        # @param [Hash] payload Optional default payload
+        #
+        # @return [self]
+        #
+        # @api public
+        def register_event(event_id, payload = EMPTY_HASH)
+          __bus__.events[event_id] = Event.new(event_id, payload)
+          self
+        end
+        # Publish an event
+        #
+        # @param [String] event_id The event identifier
+        # @param [Hash] payload An optional payload
+        #
+        # @api public
+        def publish(event_id, payload = EMPTY_HASH)
+          __bus__.publish(event_id, payload)
+          self
+        end
+        alias_method :trigger, :publish
+
+        # Subscribe to events.
+        #
+        # If the query parameter is provided, filters events by payload.
+        #
+        # @param [Symbol,String,Object] object_or_event_id The event identifier or a listener object
+        # @param [Hash] query An optional event filter
+        #
+        # @return [Object] self
+        #
+        # @api public
+        def subscribe(object_or_event_id, query = EMPTY_HASH, &block)
+          if block
+            __bus__.subscribe(object_or_event_id, query, &block)
+          else
+            __bus__.attach(object_or_event_id, query)
+          end
+          self
+        end
+
+        # Unsubscribe a listener
+        #
+        # @param [Object] listener The listener object
+        #
+        # @return [self]
+        #
+        # @api public
+        def unsubscribe(listener)
+          __bus__.detach(listener)
+        end
+
+        # Return true if a given listener has been subscribed to any event
+        #
+        # @api public
+        def subscribed?(listener)
+          __bus__.subscribed?(listener)
+        end
+
+        # Utility method which yields event with each of its listeners
+        #
+        # Listeners are already filtered out when query was provided during
+        # subscription
+        #
+        # @param [Symbol,String] event_id The event identifier
+        # param [Hash] payload An optional payload
+        #
+        # @api public
+        def process(event_id, payload = EMPTY_HASH, &block)
+          __bus__.process(event_id, payload, &block)
+        end
+
+        # Internal event bus
+        #
+        # @return [Bus]
+        #
+        # @api private
+        def __bus__
+          @__bus__ ||= self.class.new_bus
+        end
+      end
+    end
+  end
+end

data/lib/dry/events/version.rb

@@ -0,0 +1,5 @@
+module Dry
+  module Events
+    VERSION = '0.1.0'.freeze
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+if RUBY_ENGINE == 'ruby' && ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end
+
+begin
+  require 'byebug'
+rescue LoadError; end
+
+require 'dry-events'
+
+SPEC_ROOT = Pathname(__dir__)
+
+Dir[SPEC_ROOT.join('shared/**/*.rb')].each(&method(:require))
+Dir[SPEC_ROOT.join('support/**/*.rb')].each(&method(:require))
+
+RSpec.configure do |config|
+  config.disable_monkey_patching!
+
+  config.after(:example) do
+    Dry::Events::Publisher.instance_variable_set(:@__registry__, Concurrent::Map.new)
+  end
+end

data/spec/unit/dry/events/listener_spec.rb

@@ -0,0 +1,31 @@
+require 'dry/events/listener'
+
+RSpec.describe Dry::Events::Listener do
+  subject(:listener) do
+    Class.new {
+      include Dry::Events::Listener[:test_publisher]
+    }
+  end
+
+  let!(:publisher) do
+    Class.new {
+      include Dry::Events::Publisher[:test_publisher]
+
+      register_event :test_event
+    }.new
+  end
+
+  describe '.subscribe' do
+    it 'subscribes a listener at class level' do
+      result = []
+
+      listener.subscribe(:test_event) do |event|
+        result << event.id
+      end
+
+      publisher.publish(:test_event)
+
+      expect(result).to eql([:test_event])
+    end
+  end
+end

data/spec/unit/dry/events/publisher_spec.rb

@@ -0,0 +1,125 @@
+require 'dry/events/publisher'
+
+RSpec.describe Dry::Events::Publisher do
+  subject(:publisher) do
+    Class.new {
+      include Dry::Events::Publisher[:test_publisher]
+
+      register_event :test_event
+    }.new
+  end
+
+  describe '.[]' do
+    it 'creates a publisher extension with provided id' do
+      publisher = Class.new do
+        include Dry::Events::Publisher[:my_publisher]
+      end
+
+      expect(Dry::Events::Publisher.registry[:my_publisher]).to be(publisher)
+    end
+
+    it 'does not allow same id to be used for than once' do
+      create_publisher = -> do
+        Class.new do
+          include Dry::Events::Publisher[:my_publisher]
+        end
+      end
+
+      create_publisher.()
+
+      expect { create_publisher.() }.to raise_error(Dry::Events::PublisherAlreadyRegisteredError, /my_publisher/)
+    end
+  end
+
+  describe '.subscribe' do
+    it 'subscribes a listener at class level' do
+      listener = -> * { }
+
+      publisher.class.subscribe(:test_event, &listener)
+
+      expect(publisher.subscribed?(listener)).to be(true)
+    end
+  end
+
+  describe '#register_event' do
+    it 'registers a new event at instance level' do
+      listener = -> * { }
+
+      publisher.register_event(:test_another_event).subscribe(:test_another_event, &listener)
+
+      expect(publisher.subscribed?(listener)).to be(true)
+    end
+  end
+
+  describe '#subscribe' do
+    it 'subscribes a listener function' do
+      listener = -> * { }
+
+      publisher.subscribe(:test_event, &listener)
+
+      expect(publisher.subscribed?(listener)).to be(true)
+    end
+
+    it 'subscribes a listener object' do
+      listener = Class.new do
+        attr_reader :captured
+
+        def initialize
+          @captured = []
+        end
+
+        def on_test_event(event)
+          captured << event[:message]
+        end
+      end.new
+
+      publisher.subscribe(listener).publish(:test_event, message: 'it works')
+
+      expect(listener.captured).to eql(['it works'])
+
+      publisher.unsubscribe(listener)
+
+      publisher.publish(:test_event, message: 'it works')
+
+      expect(listener.captured).to eql(['it works'])
+    end
+  end
+
+  describe '#publish' do
+    it 'publishes an event' do
+      result = []
+      listener = -> event { result << event[:message] }
+
+      publisher.subscribe(:test_event, &listener).publish(:test_event, message: 'it works')
+
+      expect(result).to eql(['it works'])
+    end
+
+    it 'publishes an event filtered by a query' do
+      result = []
+      listener = -> test: { result << test }
+
+      publisher.
+        subscribe(:test_event, test: true, &listener).
+        publish(:test_event, test: false).
+        publish(:test_event, test: true)
+
+      expect(result).to eql([true])
+    end
+  end
+
+  describe '#process' do
+    it 'yields event and its listeners' do
+      result = []
+      listener = -> event { result << event.id }
+
+      publisher.subscribe(:test_event, &listener)
+
+      publisher.process(:test_event) do |event, listener|
+        listener.(event)
+      end
+
+      expect(result).to eql([:test_event])
+    end
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: dry-events
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Solnica
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dry-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: dry-equalizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: 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: rspec
+  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: 
+email:
+- piotr.solnica+oss@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CONTRIBUTING.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- dry-events.gemspec
+- lib/dry-events.rb
+- lib/dry/events.rb
+- lib/dry/events/bus.rb
+- lib/dry/events/constants.rb
+- lib/dry/events/event.rb
+- lib/dry/events/listener.rb
+- lib/dry/events/publisher.rb
+- lib/dry/events/version.rb
+- spec/spec_helper.rb
+- spec/unit/dry/events/listener_spec.rb
+- spec/unit/dry/events/publisher_spec.rb
+homepage: https://github.com/dry-rb/dry-events
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Pub/sub system
+test_files:
+- spec/spec_helper.rb
+- spec/unit/dry/events/listener_spec.rb
+- spec/unit/dry/events/publisher_spec.rb