koine-event_manager 2.1.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bfb4bada53604e54aa8118063adccfcc996e137c387ba967521a1af7c99828e1
-  data.tar.gz: b043883d06200820bba474a3191db5d4f6816c67be5f9f02a3a2c7c7852740bc
+  metadata.gz: 48dfe1c350d523d6dc0b09cec81848a225fa41cf02edd07fbe3c902f4e9ba826
+  data.tar.gz: c5d594bac4dc7e8ed338d485e5e5a2fcd4558f35533cd496d4497783644a543f
 SHA512:
-  metadata.gz: 1b996259bb8fc3c71633fb6a314d0fe433825d4bfeedd6b444db9b2e8f59c4a9e27c5b521b951ca6b1b76071f603f28b3a2b5c48a6b93210ba0de4a985f2c22f
-  data.tar.gz: 3ad407c03c10a251c2dd2450095cc9714af03d194282075e98ba4bfae0610bb350004c057445142cbeeac78cfae305ff2f77d8a6d4f398b6b714f6b8ae6761a0
+  metadata.gz: a465c356d1944acb9cb2c2aea7f4f269877a253dce7fce66798cb9cd6560c80c196c0151f7fbba0c746e6816bbca3038ac31f6e0a1bc272d42696f52b6af7755
+  data.tar.gz: 87700e2f619c41c382cace295d90b3d76afba14c3af5174769117b78196796199ed6921faa4b6e97ece79bb1889589b6b48089d9dc811d71d82081347230fcd1

data/.github/workflows/ci.yml

@@ -0,0 +1,49 @@
+name: CI
+
+on:
+  push:
+    branches: [ master, update ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4']
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby ${{ matrix.ruby-version }}
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+
+    - name: Run tests
+      run: bundle exec rspec
+
+    - name: Upload coverage to Coveralls
+      if: matrix.ruby-version == '3.4'
+      uses: coverallsapp/github-action@v2
+      with:
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        path-to-lcov: ./coverage/lcov.info
+      continue-on-error: true
+
+  rubocop:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: '3.4'
+        bundler-cache: true
+
+    - name: Run RuboCop
+      run: bundle exec rubocop

data/.gitignore

@@ -8,3 +8,4 @@
 /spec/reports/
 /tmp/
 .rspec_status
+/.claude

data/.rubocop.yml

@@ -1,13 +1,17 @@
-require: rubocop-rspec
-
 # https://github.com/rubocop-hq/rubocop/blob/36404b40cbdac743b596c8520877c4ca3eee5691/manual/cops.md
 
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 3.0
   Exclude:
     - config/environment.rb
     - apps/web/application.rb
-Layout/AlignParameters:
+    - vendor/**/*
+    - node_modules/**/*
+    - bin/**/*
+  NewCops: enable
+  SuggestExtensions: false
+
+Layout/ParameterAlignment:
   Enabled: false
 
 Layout/ClosingParenthesisIndentation:
@@ -16,10 +20,10 @@ Layout/ClosingParenthesisIndentation:
 Layout/FirstParameterIndentation:
   Enabled: false
 
-Layout/IndentHash:
+Layout/FirstHashElementIndentation:
   Enabled: false
 
-Layout/IndentArray:
+Layout/FirstArrayElementIndentation:
   Enabled: false
 
 Layout/MultilineMethodCallIndentation:
@@ -39,7 +43,7 @@ Metrics/BlockLength:
   Exclude:
     - 'spec/**/*_spec.rb'
 
-Metrics/LineLength:
+Layout/LineLength:
   Max: 100
 
 Style/CommentedKeyword:
@@ -59,23 +63,3 @@ Style/TrailingCommaInArrayLiteral:
 
 Style/TrailingCommaInHashLiteral:
   EnforcedStyleForMultiline: comma
-
-# rubocop-rspec cops
-
-Capybara/FeatureMethods:
-  Enabled: false
-
-FactoryBot/CreateList:
-  Enabled: false
-
-RSpec/ExampleLength:
-  Enabled: false
-
-RSpec/MessageSpies:
-  Enabled: false
-
-RSpec/MultipleExpectations:
-  Enabled: false
-
-RSpec/NestedGroups:
-  Enabled: false

data/Gemfile

@@ -6,3 +6,13 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in koine-event_manager.gemspec
 gemspec
+
+group :development, :test do
+  gem 'coveralls', require: false
+  gem 'rake', '~> 13.0'
+  gem 'rspec', '~> 3.13'
+  gem 'rubocop', '~> 1.0', require: false
+  gem 'rubocop-rake', '~> 0.6', require: false
+  gem 'rubocop-rspec', '~> 3.0', require: false
+  gem 'simplecov', require: false
+end

data/README.md

@@ -1,12 +1,25 @@
 # Koine::EventManager
 
-Event manager for ruby.
+A simple and lightweight event management library for Ruby that enables event-driven architecture through a publish-subscribe pattern.
 
-[![Build Status](https://travis-ci.org/mjacobus/koine-event-manager.svg)](https://travis-ci.org/mjacobus/koine-event-manager)
+[![CI](https://github.com/mjacobus/koine-event-manager/actions/workflows/ci.yml/badge.svg)](https://github.com/mjacobus/koine-event-manager/actions/workflows/ci.yml)
 [![Coverage Status](https://coveralls.io/repos/github/mjacobus/koine-event-manager/badge.svg?branch=master)](https://coveralls.io/github/mjacobus/koine-event-manager?branch=master)
 [![Code Climate](https://codeclimate.com/github/mjacobus/koine-event-manager/badges/gpa.svg)](https://codeclimate.com/github/mjacobus/koine-event-manager)
 [![Gem Version](https://badge.fury.io/rb/koine-event_manager.svg)](https://badge.fury.io/rb/koine-event_manager)
 
+## Features
+
+- **Simple API** - Easy to understand and use
+- **Block-based listeners** - Quick inline event handlers
+- **Object-based subscribers** - Reusable event handling objects
+- **Event inheritance** - Listen to parent event classes and receive child events
+- **No dependencies** - Pure Ruby implementation
+- **Thread-safe operations** - Safe for concurrent use
+
+## Requirements
+
+- Ruby >= 3.0
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -17,7 +30,7 @@ gem 'koine-event_manager'
 
 And then execute:
 
-    $ bundle
+    $ bundle install
 
 Or install it yourself as:
 
@@ -25,35 +38,64 @@ Or install it yourself as:
 
 ## Usage
 
-Here follows a simple example
+### Basic Example
 
 ```ruby
+require 'koine/event_manager'
+
+# Define your event
+class UserSignedIn
+  attr_reader :user
+
+  def initialize(user)
+    @user = user
+  end
+end
+
+# Create the event manager
 event_manager = Koine::EventManager::EventManager.new
 
+# Register a listener
 event_manager.listen_to(UserSignedIn) do |event|
+  puts "Welcome, #{event.user.name}!"
   WelcomeEmail.new(event.user).send
 end
+
+# Trigger the event
+user = User.find(123)
+event_manager.trigger(UserSignedIn.new(user))
 ```
 
-In your controller, or service:
+### Block-based Listeners
+
+Use block-based listeners for simple, inline event handlers:
 
 ```ruby
-class UserController < ApplicationController
-  def create
-    @user = User.create(user_params)
+event_manager = Koine::EventManager::EventManager.new
 
-    event_manager.trigger(UserSignedIn.new(@user))
+event_manager.listen_to(UserSignedIn) do |event|
+  WelcomeEmail.new(event.user).send
+end
 
-    respond_with(@user)
-  end
+event_manager.listen_to(UserRemovedAccount) do |event|
+  CleanupJob.perform_later(event.user.id)
 end
+
+# Trigger events
+event_manager.trigger(UserSignedIn.new(user))
 ```
 
-You can also create event listeners:
+**When to use:** Quick, one-off event handlers that don't need to be reused.
+
+### Event Listener Classes
+
+For better organization, create reusable listener classes:
 
 ```ruby
 class UserListener < Koine::EventManager::EventListener
-  def initializer
+  def initialize
+    super
+
     listen_to(UserSignedIn) do |event|
       WelcomeEmail.new(event.user).send
     end
@@ -63,53 +105,241 @@ class UserListener < Koine::EventManager::EventListener
     end
   end
 end
-```
 
-And attach to the event manager:
-
-```ruby
+# Attach the listener to the event manager
 event_manager = Koine::EventManager::EventManager.new
 event_manager.attach_listener(UserListener.new)
 
-# and of course later, you can detach listeners, if you want
+# Trigger events
+event_manager.trigger(UserSignedIn.new(some_user))
+
+# Later, you can detach listeners if needed
 event_manager.detach_listener(event_manager.listeners.last)
 ```
 
-And trigger the event on the event manager
-
-```ruby
-event_manager.trigger(UserSignedIn.new(some_user))
-```
+**When to use:** Related event handlers that should be grouped together and potentially attached/detached as a unit.
 
 ### Subscribers
 
-You can add and remove subscribers as follows:
+Subscribers are objects that implement a `publish` method. They provide a more object-oriented approach to event handling:
 
 ```ruby
-class MySubscriber
+class NotificationSubscriber
   def publish(event)
-    # do something
+    case event
+    when UserSignedIn
+      send_welcome_notification(event.user)
+    when UserRemovedAccount
+      send_goodbye_notification(event.user)
+    end
   end
-end
 
-subscriber = MySubscriber.new
+  private
+
+  def send_welcome_notification(user)
+    # Send notification logic
+  end
+
+  def send_goodbye_notification(user)
+    # Send notification logic
+  end
+end
 
+# Subscribe to specific events
+subscriber = NotificationSubscriber.new
 event_manager.subscribe(subscriber, to: UserSignedIn)
+event_manager.subscribe(subscriber, to: UserRemovedAccount)
+
+# Trigger events - subscriber.publish(event) will be called
+event_manager.trigger(UserSignedIn.new(user))
+
+# Unsubscribe when no longer needed
 event_manager.unsubscribe(subscriber, from: UserSignedIn)
 ```
 
+**When to use:** Complex event handling logic that needs to be encapsulated in a class with state and multiple methods.
+
+### Event Inheritance
+
+The event manager supports event inheritance. If you listen to a parent event class, you'll also receive events from child classes:
+
+```ruby
+class UserEvent
+  attr_reader :user
+
+  def initialize(user)
+    @user = user
+  end
+end
+
+class UserSignedIn < UserEvent
+end
+
+class UserSignedOut < UserEvent
+end
+
+# Listen to the parent class
+event_manager.listen_to(UserEvent) do |event|
+  puts "User event occurred for #{event.user.name}"
+end
+
+# Both of these will trigger the listener above
+event_manager.trigger(UserSignedIn.new(user))
+event_manager.trigger(UserSignedOut.new(user))
+```
+
+### Using in Rails
+
+Here's a complete example of how to use the event manager in a Rails application:
+
+```ruby
+# app/events/user_signed_in.rb
+class UserSignedIn
+  attr_reader :user, :ip_address
+
+  def initialize(user, ip_address: nil)
+    @user = user
+    @ip_address = ip_address
+  end
+end
+
+# app/listeners/user_listener.rb
+class UserListener < Koine::EventManager::EventListener
+  def initialize
+    super
+
+    listen_to(UserSignedIn) do |event|
+      WelcomeMailer.welcome_email(event.user).deliver_later
+      TrackingService.track_login(event.user, event.ip_address)
+    end
+  end
+end
+
+# config/initializers/event_manager.rb
+Rails.application.config.event_manager = Koine::EventManager::EventManager.new
+Rails.application.config.event_manager.attach_listener(UserListener.new)
+
+# app/controllers/application_controller.rb
+class ApplicationController < ActionController::Base
+  def event_manager
+    Rails.application.config.event_manager
+  end
+end
+
+# app/controllers/sessions_controller.rb
+class SessionsController < ApplicationController
+  def create
+    @user = User.find_by(email: params[:email])
+
+    if @user&.authenticate(params[:password])
+      session[:user_id] = @user.id
+      event_manager.trigger(UserSignedIn.new(@user, ip_address: request.remote_ip))
+      redirect_to root_path, notice: 'Signed in successfully'
+    else
+      render :new, alert: 'Invalid credentials'
+    end
+  end
+end
+```
+
+### Error Isolation
+
+By default, an exception raised by a listener or subscriber propagates and aborts
+the dispatch. Pass an `on_error` callback to isolate failures so the remaining
+listeners still run:
+
+```ruby
+event_manager = Koine::EventManager::EventManager.new(
+  on_error: ->(error, event:, listener:) { Bugsnag.notify(error) }
+)
+```
+
+The callback is invoked as `on_error.call(error, event:, listener:)`, so it **must
+accept the `event:` and `listener:` keyword arguments** (the failing event and the
+listener/subscriber that raised). Use them to attribute the failure, or ignore them
+with a splat:
+
+```ruby
+on_error: ->(error, **) { Bugsnag.notify(error) }
+```
+
+Without `on_error` the behavior is unchanged (errors re-raise).
+
+### Post-commit Dispatch (Rails)
+
+`require "koine/event_manager/rails"` adds `TransactionalEventManager`, a drop-in
+subclass that defers dispatch until the current database transaction commits (or
+runs immediately when none is open), via `ActiveRecord.after_all_transactions_commit`.
+This keeps listeners from reacting to changes that a rollback would undo.
+
+```ruby
+require "koine/event_manager/rails"
+
+bus = Koine::EventManager::TransactionalEventManager.new(
+  on_error: ->(error, **) { Bugsnag.notify(error) }
+)
+```
+
+Requires ActiveRecord >= 7.2; the core library remains dependency-free, so only load
+this file from within a Rails/ActiveRecord process.
+
+Subscribers (and block listeners) are deferred by default. A reaction that must run
+**inside** the transaction — e.g. to write a related record atomically, or to raise
+and roll the whole operation back — can opt out with `after_commit: false`:
+
+```ruby
+bus.subscribe(AuditWriter.new, to: ProposalCreated)                      # post-commit, isolated
+bus.subscribe(InventoryReserver.new, to: ProposalCreated, after_commit: false) # in-transaction
+bus.listen_to(ProposalCreated, after_commit: false) { |e| ... }          # in-transaction block
+```
+
+Synchronous (`after_commit: false`) listeners run inline and their errors **propagate**
+(bypassing `on_error`), so a failed integrity reaction aborts the surrounding
+transaction. Deferred listeners stay isolated by `on_error`.
+
+## API Reference
+
+### EventManager
+
+- `EventManager.new(on_error: nil)` - Optionally isolate listener errors (see Error Isolation)
+- `listen_to(event_class, &block)` - Register a block to handle events
+- `trigger(event)` - Dispatch an event to all listeners and subscribers
+- `publish(event)` - Alias for `trigger` (pub/sub vocabulary)
+- `subscribe(subscriber, to: event_type)` - Add a subscriber for an event type
+- `unsubscribe(subscriber, from: event_type)` - Remove a subscriber
+- `attach_listener(listener)` - Attach an EventListener instance
+- `detach_listener(listener)` - Remove a listener
+- `listeners` - Get array of attached listeners
+
+### EventListener
+
+- `listen_to(event_type, &block)` - Register a block handler for an event type
+- `subscribe(subscriber, to: event_type)` - Register a subscriber object
+- `unsubscribe(subscriber, from: event_type)` - Unregister a subscriber
+- `trigger(event_object)` - Process the event through all listeners and subscribers
+
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bundle exec rspec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
-## Contributing
+### Running Tests
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/mjacobus/koine-event-manager. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+```bash
+bundle exec rspec
+```
+
+### Running Linter
 
+```bash
+bundle exec rubocop
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mjacobus/koine-event-manager. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/Rakefile

@@ -1,11 +1,8 @@
 # frozen_string_literal: true
 
 require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-# rubocop:disable Lint/HandleExceptions
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-  task default: :spec
-rescue LoadError
-end
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/koine-event_manager.gemspec

@@ -4,7 +4,6 @@ lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'koine/event_manager/version'
 
-# rubocop:disable Metrics/BlockLength
 Gem::Specification.new do |spec|
   spec.name          = 'koine-event_manager'
   spec.version       = Koine::EventManager::VERSION
@@ -15,11 +14,13 @@ Gem::Specification.new do |spec|
   spec.description   = 'Event Manager for ruby'
   spec.homepage      = 'https://github.com/mjacobus/koine-event-manager'
   spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 3.0'
 
   # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+    spec.metadata['rubygems_mfa_required'] = 'true'
   else
     raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
   end
@@ -32,12 +33,4 @@ Gem::Specification.new do |spec|
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
-
-  spec.add_development_dependency 'bundler', '~> 1.16'
-  spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'rake', '~> 10.0'
-  spec.add_development_dependency 'rspec', '~> 3.0'
-  spec.add_development_dependency 'rubocop', '0.58'
-  spec.add_development_dependency 'rubocop-rspec', '~>1.30'
-  spec.add_development_dependency 'simplecov'
 end

data/lib/koine/event_manager/event_listener.rb

@@ -3,13 +3,15 @@
 module Koine
   module EventManager
     class EventListener
-      def initialize
+      def initialize(on_error: nil)
         @listeners = {}
         @subscribers = {}
+        @on_error = on_error
       end
 
       def listen_to(event_type, &block)
         raise ArgumentError, 'block not given' unless block_given?
+
         add_listener(event_type, &block)
       end
 
@@ -29,13 +31,13 @@ module Koine
 
       def trigger(event_object)
         listeners_for(event_object.class).each do |block|
-          block.call(event_object)
+          dispatch(event_object, block) { block.call(event_object) }
         end
 
         subscribers.each do |subscriber, events|
           events.each do |event|
             if event_object.class.ancestors.map(&:to_s).include?(event.to_s)
-              subscriber.publish(event_object)
+              dispatch(event_object, subscriber) { subscriber.publish(event_object) }
             end
           end
         end
@@ -49,13 +51,20 @@ module Koine
 
       private
 
+      def dispatch(event, listener)
+        yield
+      rescue StandardError => e
+        raise if @on_error.nil?
+
+        @on_error.call(e, event: event, listener: listener)
+      end
+
       def add_listener(event_type, &block)
         listeners[event_type.to_s] ||= []
         listeners[event_type.to_s] << block
       end
 
-      attr_reader :listeners
-      attr_reader :subscribers
+      attr_reader :listeners, :subscribers
     end
   end
 end

data/lib/koine/event_manager/event_manager.rb

@@ -3,8 +3,13 @@
 module Koine
   module EventManager
     class EventManager
-      def initialize
-        @internal_listener = EventListener.new
+      def initialize(on_error: nil)
+        @on_error = on_error
+        @internal_listener = EventListener.new(on_error: on_error)
+      end
+
+      def publish(event)
+        trigger(event)
       end
 
       def listen_to(event, &block)
@@ -31,13 +36,23 @@ module Koine
         @internal_listener.trigger(event)
 
         listeners.each do |listener|
-          listener.trigger(event)
+          dispatch(event, listener) { listener.trigger(event) }
         end
       end
 
       def listeners
         @listeners ||= []
       end
+
+      private
+
+      def dispatch(event, listener)
+        yield
+      rescue StandardError => e
+        raise if @on_error.nil?
+
+        @on_error.call(e, event: event, listener: listener)
+      end
     end
   end
 end

data/lib/koine/event_manager/rails.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'koine/event_manager'
+
+module Koine
+  module EventManager
+    # Dispatches listeners after the current DB transaction commits (or runs
+    # immediately when none is open), so they never react to changes a rollback
+    # would undo. Requires ActiveRecord >= 7.2.
+    #
+    # Individual subscribers/listeners may opt into synchronous, in-transaction
+    # dispatch with `after_commit: false`. Those run inline and their errors
+    # propagate (bypassing `on_error` isolation), so an integrity reaction can
+    # abort the surrounding transaction. Post-commit listeners stay isolated.
+    class TransactionalEventManager < EventManager
+      alias deferred_dispatch trigger
+
+      def initialize(on_error: nil)
+        super
+        # In-transaction listeners: no on_error isolation, so a failure propagates
+        # and can roll the surrounding transaction back.
+        @synchronous = EventListener.new
+      end
+
+      def subscribe(subscriber, to:, after_commit: true)
+        return @synchronous.subscribe(subscriber, to: to) unless after_commit
+
+        super(subscriber, to: to)
+      end
+
+      def listen_to(event, after_commit: true, &block)
+        return @synchronous.listen_to(event, &block) unless after_commit
+
+        super(event, &block)
+      end
+
+      def unsubscribe(subscriber, from:)
+        @synchronous.unsubscribe(subscriber, from: from)
+        super
+      end
+
+      def trigger(event)
+        @synchronous.trigger(event)
+
+        unless active_record_available?
+          raise LoadError, 'TransactionalEventManager requires ActiveRecord >= 7.2 ' \
+                           '(after_all_transactions_commit). Load Rails before using it.'
+        end
+
+        ::ActiveRecord.after_all_transactions_commit do
+          deferred_dispatch(event)
+        end
+      end
+
+      private :deferred_dispatch
+
+      private
+
+      def active_record_available?
+        defined?(::ActiveRecord) &&
+          ::ActiveRecord.respond_to?(:after_all_transactions_commit)
+      end
+    end
+  end
+end

data/lib/koine/event_manager/version.rb

@@ -2,6 +2,6 @@
 
 module Koine
   module EventManager
-    VERSION = '2.1.1'
+    VERSION = '3.1.0'
   end
 end

metadata

@@ -1,113 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: koine-event_manager
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 3.1.0
 platform: ruby
 authors:
 - Marcelo Jacobus
-autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-26 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.16'
-- !ruby/object:Gem::Dependency
-  name: coveralls
-  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: '10.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '10.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: rubocop
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '0.58'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: '0.58'
-- !ruby/object:Gem::Dependency
-  name: rubocop-rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.30'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.30'
-- !ruby/object:Gem::Dependency
-  name: simplecov
-  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'
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
 description: Event Manager for ruby
 email:
 - marcelo.jacobus@gmail.com
@@ -115,11 +16,11 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
 - ".scrutinizer.yml"
-- ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -131,13 +32,14 @@ files:
 - lib/koine/event_manager.rb
 - lib/koine/event_manager/event_listener.rb
 - lib/koine/event_manager/event_manager.rb
+- lib/koine/event_manager/rails.rb
 - lib/koine/event_manager/version.rb
 homepage: https://github.com/mjacobus/koine-event-manager
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -145,16 +47,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Event Manager for ruby
 test_files: []

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-cache: bundle
-script:
-  - COVERALLS=1 bundle exec rake
-rvm:
-  - 2.4.4
-before_install: gem install bundler -v 1.16.3