eventish 0.3.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: affdd6406fe05bcc51fa60a0bdd1e894c47412e8d8c347e2f8e4e8ed0d846757
-  data.tar.gz: 754e24d0338cb7eb4c6eb299371d2880b0b867a85fadb0b604ea3511a8e9ee32
+  metadata.gz: 419b6aafd21ffe1e4c9041549dc80b77fe7973975732a44feeac183f28d8f474
+  data.tar.gz: 50e7f43233ee05c86c930807677cdee82a21471b6d4f4c4a037ea1062e6f3127
 SHA512:
-  metadata.gz: 23e2bd4268d4c28a3691327e499552815fbe05d6ada3e17a887e812ec2666d4f65c8c78ac878d7ef0426403cd61760134a06f7c0d9a07da6c8e73fe440da9da0
-  data.tar.gz: 530d9dcd90223304e1606cbfe909ccf223d1353d1409a230807b29cf6258fa740228235975f0411484b99886ab961349a84ca73a3a432842090c7b95d69cf713
+  metadata.gz: b768c6c9baaac52a7b3bd841569714727a43527d90956881645e17b11afc5be65e14bfec6424d4a877f12d7294dc4a69edaf94a55b62b4da7f9bb133d1d69c41
+  data.tar.gz: a272f0d0420ae08b627be7fcb975d7051af6f7662b2089f91b4719a1b97fab70fd3cc7872031fba83ccb8d61881953f08d921476b4918cd9dfff82be05d6272b

data/README.md

@@ -1,20 +1,27 @@
 # Eventish
 
 [![Gem Version](https://badge.fury.io/rb/eventish.svg)](https://badge.fury.io/rb/eventish)
-[![Specs](https://github.com/blocknotes/eventish/actions/workflows/main.yml/badge.svg)](https://github.com/blocknotes/eventish/actions/workflows/main.yml)
+[![Specs Rails 6](https://github.com/blocknotes/eventish/actions/workflows/rails6.yml/badge.svg)](https://github.com/blocknotes/eventish/actions/workflows/rails6.yml)
+[![Specs Rails 7](https://github.com/blocknotes/eventish/actions/workflows/rails7.yml/badge.svg)](https://github.com/blocknotes/eventish/actions/workflows/rails7.yml)
+[![Linters](https://github.com/blocknotes/eventish/actions/workflows/linters.yml/badge.svg)](https://github.com/blocknotes/eventish/actions/workflows/linters.yml)
 
-Yet another opinionated events library which proposes a simple API to handle... events 🎉
+Yet another events library with a _simple_ API to handle... events :tada:
 
-The main features:
+Main features:
 - _composable_: just require the components that you need;
-- with _adapters_: support ActiveSupport::Notifications for pub/sub events;
-- with _async events_: support ActiveJob for background execution;
-- with _callbacks_ wrapper: support ActiveRecord.
+- with [adapters](#adapters): support ActiveSupport::Notifications and Wisper for pub/sub events;
+- with [async events](#async-events): support ActiveJob for events background execution;
+- with [callbacks wrapper](#callbacks): support ActiveRecord callbacks.
+- with [plugins](#plugins): a simple logger and a Rails logger are included.
+
+Please :star: if you like it.
+
+> Do you want to speak by events? Try _eventish_ :smile:
 
 ## Install
 
 - Add to your Gemfile: `gem 'eventish'` (and execute `bundle`)
-- Create an initializer - _config/initializers/eventish.rb_:
+- Create an initializer - ex. _config/initializers/eventish.rb_:
 
 ```rb
 require 'eventish/adapters/active_support'
@@ -38,7 +45,7 @@ Rails.configuration.after_initialize do
 end
 ```
 
-- Create some events - _app/events/main/app_loaded_event.rb_:
+- Create some events - ex. _app/events/main/app_loaded_event.rb_:
 
 ```rb
 module Main
@@ -52,9 +59,11 @@ end
 
 For a complete example please take a look at the [dummy app](spec/dummy) in the specs.
 
-### Adatpers
+### Adapters
 
-Only _ActiveSupport_ is supported for now.
+Used for events subscription and publishing.
+
+_ActiveSupport Notification_:
 
 ```rb
 # initializer setup
@@ -65,6 +74,18 @@ Eventish.setup do |config|
 end
 ```
 
+_Wisper_ (NOTE: around callback wrappers are not supported):
+
+```rb
+# initializer setup
+require 'wisper'
+require 'eventish/adapters/wisper'
+
+Eventish.setup do |config|
+  config.adapter = Eventish::Adapters::Wisper
+end
+```
+
 ### Simple events
 
 Generic events not related to a specific component.
@@ -78,7 +99,7 @@ Rails.configuration.after_initialize do
 end
 ```
 
-Sample event - _app/events/main/test_event.rb_:
+Sample event - ex. _app/events/main/test_event.rb_:
 
 ```rb
 module Main
@@ -97,14 +118,20 @@ module Main
 end
 ```
 
-Publish the event: `Eventish.publish('some_event')`
+Publish the event with:
+
+```rb
+Eventish.publish('some_event')
+```
 
 ### Async events
 
-Events executed in a background process. Only _ActiveJob_ is supported for now.
+Events executed in a background process.
+Only _ActiveJob_ is supported for now.
 
 ```rb
 # initializer setup
+require 'active_job/railtie'
 require 'eventish/active_job_event'
 
 Rails.configuration.after_initialize do
@@ -112,7 +139,7 @@ Rails.configuration.after_initialize do
 end
 ```
 
-Sample event - _app/events/notifications/user_after_save_commit_event.rb_:
+Sample event - ex. _app/events/notifications/user_after_save_commit_event.rb_:
 
 ```rb
 module Notifications
@@ -126,7 +153,7 @@ end
 
 ### Callbacks
 
-Only for ActiveRecord, callbacks wrapper are available with the postfix `_event` (ex. `after_commit_event SomeEvent`).
+Wrappers for ActiveRecord callbacks using the postfix `_event` (ex. `after_commit_event SomeEvent`).
 
 ```rb
 # initializer setup
@@ -134,6 +161,7 @@ require 'eventish/active_record/callback'
 ```
 
 ```rb
+# sample model
 class SomeModel < ActiveRecord::Base
   extend ::Eventish::ActiveRecord::Callback
 
@@ -143,6 +171,34 @@ end
 
 The related callback will be setup by the wrapper and the specified event class will be invoked accordingly.
 
+### Plugins
+
+A plugins system is available for custom processing, a logger and a Rails logger are included in the gem.
+
+```rb
+# initializer setup
+require 'eventish/plugins/rails_logger' # without rails_ for a simple stdout logger
+
+Eventish.setup do |config|
+  config.before_event = [Eventish::Plugins::RailsLogger]
+  config.after_event = [Eventish::Plugins::RailsLogger]
+end
+```
+
+A sample plugin:
+
+```rb
+module Eventish::Plugins::RailsLogger
+  class << self
+    def call(target, _args, event:, hook: nil, &_block)
+      Rails.logger.debug "EVENT: #{hook} #{event.class.event_name} on #{target.inspect}"
+    end
+  end
+end
+```
+
+Plugins can also be configured for single events overriding _before_event_ and _after_event_.
+
 ## Do you like it? Star it!
 
 If you use this component just star it. A developer is more motivated to improve a project when there is some interest.

data/lib/eventish/active_job_event.rb

@@ -7,7 +7,10 @@ module Eventish
     end
 
     def perform(target, args)
+      self.class.before_event.each { |plugin| plugin.call(target, args, event: self, hook: :before) }
       call(target, args)
+      self.class.after_event.each { |plugin| plugin.call(target, args, event: self, hook: :after) }
+      self
     end
 
     class << self

data/lib/eventish/active_record/callback.rb

@@ -4,103 +4,126 @@ module Eventish
   module ActiveRecord
     module Callback
       # Init events
-      def after_initialize_event(event)
-        after_initialize -> { ::Eventish.publish(event, self) }
+      def after_initialize_event(*args)
+        event = args.shift
+        after_initialize -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_find_event(event)
-        after_find -> { ::Eventish.publish(event, self) }
+      def after_find_event(*args)
+        event = args.shift
+        after_find -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Validation events
-      def before_validation_event(event)
-        before_validation -> { ::Eventish.publish(event, self) }
+      def before_validation_event(*args)
+        event = args.shift
+        before_validation -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_validation_event(event)
-        after_validation -> { ::Eventish.publish(event, self) }
+      def after_validation_event(*args)
+        event = args.shift
+        after_validation -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Create events
-      def before_create_event(event)
-        before_create -> { ::Eventish.publish(event, self) }
+      def before_create_event(*args)
+        event = args.shift
+        before_create -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def around_create_event(event)
-        around_create ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      def around_create_event(*args)
+        event = args.shift
+        around_create ->(_object, block) { ::Eventish.publish(event, self, block: block) }, *args
       end
 
-      def after_create_event(event)
-        after_create -> { ::Eventish.publish(event, self) }
+      def after_create_event(*args)
+        event = args.shift
+        after_create -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Update events
-      def before_update_event(event)
-        before_update -> { ::Eventish.publish(event, self) }
+      def before_update_event(*args)
+        event = args.shift
+        before_update -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def around_update_event(event)
-        around_update ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      def around_update_event(*args)
+        event = args.shift
+        around_update ->(_object, block) { ::Eventish.publish(event, self, block: block) }, *args
       end
 
-      def after_update_event(event)
-        after_update -> { ::Eventish.publish(event, self) }
+      def after_update_event(*args)
+        event = args.shift
+        after_update -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Save events
-      def before_save_event(event)
-        before_save -> { ::Eventish.publish(event, self) }
+      def before_save_event(*args)
+        event = args.shift
+        before_save -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def around_save_event(event)
-        around_save ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      def around_save_event(*args)
+        event = args.shift
+        around_save ->(_object, block) { ::Eventish.publish(event, self, block: block) }, *args
       end
 
-      def after_save_event(event)
-        after_save -> { ::Eventish.publish(event, self) }
+      def after_save_event(*args)
+        event = args.shift
+        after_save -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Destroy events
-      def before_destroy_event(event)
-        before_destroy -> { ::Eventish.publish(event, self) }
+      def before_destroy_event(*args)
+        event = args.shift
+        before_destroy -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def around_destroy_event(event)
-        around_destroy ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      def around_destroy_event(*args)
+        event = args.shift
+        around_destroy ->(_object, block) { ::Eventish.publish(event, self, block: block) }, *args
       end
 
-      def after_destroy_event(event)
-        after_destroy -> { ::Eventish.publish(event, self) }
+      def after_destroy_event(*args)
+        event = args.shift
+        after_destroy -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Commit events
-      def after_commit_event(event)
-        after_commit -> { ::Eventish.publish(event, self) }
+      def after_commit_event(*args)
+        event = args.shift
+        after_commit -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_create_commit_event(event)
-        after_create_commit -> { ::Eventish.publish(event, self) }
+      def after_create_commit_event(*args)
+        event = args.shift
+        after_create_commit -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_update_commit_event(event)
-        after_update_commit -> { ::Eventish.publish(event, self) }
+      def after_update_commit_event(*args)
+        event = args.shift
+        after_update_commit -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_save_commit_event(event)
-        after_save_commit -> { ::Eventish.publish(event, self) }
+      def after_save_commit_event(*args)
+        event = args.shift
+        after_save_commit -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_destroy_commit_event(event)
-        after_destroy_commit -> { ::Eventish.publish(event, self) }
+      def after_destroy_commit_event(*args)
+        event = args.shift
+        after_destroy_commit -> { ::Eventish.publish(event, self) }, *args
       end
 
-      def after_rollback_event(event)
-        after_rollback -> { ::Eventish.publish(event, self) }
+      def after_rollback_event(*args)
+        event = args.shift
+        after_rollback -> { ::Eventish.publish(event, self) }, *args
       end
 
       # Touch events
-      def after_touch_event(event)
-        after_touch -> { ::Eventish.publish(event, self) }
+      def after_touch_event(*args)
+        event = args.shift
+        after_touch -> { ::Eventish.publish(event, self) }, *args
       end
     end
   end

data/lib/eventish/adapters/active_support.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Eventish
-  class Adapters
+  module Adapters
     class ActiveSupport
       class << self
         def publish(event, target = nil, block: nil)
@@ -15,16 +15,19 @@ module Eventish
           raise ArgumentError, 'Missing event to subscribe' if event.nil?
           raise ArgumentError, 'Missing handler for subscription' if handler.nil?
 
-          ::ActiveSupport::Notifications.subscribe(event.to_s) do |name, start, finish, id, payload|
+          subscriber = ::ActiveSupport::Notifications.subscribe(event.to_s) do |name, start, finish, id, payload|
             args = { event: name, id: id, start: start, finish: finish }
             handler.trigger(payload[:target], args, &payload.dig(:options, :block))
           end
+          Eventish.subscribers[event.to_s] = subscriber
+          subscriber
         end
 
         def unsubscribe(event)
           raise ArgumentError, 'Missing event to unsubscribe' if event.nil?
 
           ::ActiveSupport::Notifications.unsubscribe(event.to_s)
+          Eventish.subscribers.delete(event.to_s)
         end
       end
     end

data/lib/eventish/adapters/wisper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Eventish
+  module Adapters
+    class Wisper
+      class << self
+        include ::Wisper::Publisher
+
+        def publish(event, target = nil, block: nil)
+          raise ArgumentError, 'Missing event to publish' if event.nil?
+
+          options = block ? { block: block } : {} # TODO: verify block feature
+          broadcast(event.to_s, target, options)
+        end
+
+        def subscribe(event, handler)
+          raise ArgumentError, 'Missing event to subscribe' if event.nil?
+          raise ArgumentError, 'Missing handler for subscription' if handler.nil?
+
+          ::Wisper.subscribe(handler.new, on: event.to_s, with: :call).tap do |subscriber|
+            Eventish.subscribers[event.to_s] = subscriber
+          end
+        end
+
+        def unsubscribe(event)
+          raise ArgumentError, 'Missing event to unsubscribe' if event.nil?
+
+          subscriber = Eventish.subscribers[event.to_s]
+          ::Wisper.unsubscribe(subscriber)
+          Eventish.subscribers.delete(event.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/eventish/event_api.rb

@@ -6,6 +6,14 @@ module Eventish
       other&.priority <=> priority
     end
 
+    def after_event
+      Eventish.config.after_event || []
+    end
+
+    def before_event
+      Eventish.config.before_event || []
+    end
+
     def event_name
       @event_name ||= to_s
     end
@@ -19,8 +27,14 @@ module Eventish
     end
 
     def subscribe_all
-      # iterate the descendants
-      ObjectSpace.each_object(singleton_class).sort.each(&:subscribe)
+      ignore_events = [Eventish::SimpleEvent]
+      ignore_events.push(Eventish::ActiveJobEvent) if defined? Eventish::ActiveJobEvent
+      events = Eventish.descendants(self).sort
+      (events - ignore_events).each(&:subscribe)
+    end
+
+    def unsubscribe
+      Eventish.adapter.unsubscribe(event_name)
     end
   end
 end

data/lib/eventish/plugins/logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Eventish
+  module Plugins
+    class Logger
+      class << self
+        def call(target, _args, event:, hook: nil, &_block)
+          puts "[#{Time.now}] EVENT: #{hook} #{event.class.event_name} on #{target.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/eventish/plugins/rails_logger.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Eventish
+  module Plugins
+    class RailsLogger
+      class << self
+        def call(target, _args, event:, hook: nil, &_block)
+          ::Rails.logger.debug "EVENT: #{hook} #{event.class.event_name} on #{target.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/eventish/simple_event.rb

@@ -10,7 +10,11 @@ module Eventish
       include EventApi
 
       def trigger(target, args, &block)
-        new.call(target, args, &block)
+        event = new
+        before_event.each { |plugin| plugin.call(target, args, event: event, hook: :before, &block) }
+        event.call(target, args, &block)
+        after_event.each { |plugin| plugin.call(target, args, event: event, hook: :after, &block) }
+        event
       end
     end
   end

data/lib/eventish/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Eventish # :nodoc:
-  VERSION = '0.3.2'
+  VERSION = '0.5.0'
 end

data/lib/eventish.rb

@@ -4,7 +4,7 @@ require_relative 'eventish/event_api'
 require_relative 'eventish/simple_event'
 
 module Eventish
-  OPTIONS = %i[adapter].freeze
+  OPTIONS = %i[adapter after_event before_event].freeze
 
   AdapterError = Class.new(StandardError)
 
@@ -18,6 +18,17 @@ module Eventish
     @options ||= Struct.new(*OPTIONS).new # rubocop:disable Naming/MemoizedInstanceVariableName
   end
 
+  # From Rails 6.0
+  def descendants(klass)
+    descendants = []
+    ObjectSpace.each_object(klass.singleton_class) do |k|
+      next if k.singleton_class?
+
+      descendants.unshift k unless k == self
+    end
+    descendants
+  end
+
   def publish(event_name, target = nil, block: nil)
     config.adapter&.publish(event_name, target, block: block)
   end
@@ -29,4 +40,8 @@ module Eventish
 
     @options
   end
+
+  def subscribers
+    @subscribers ||= {}
+  end
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: eventish
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-20 00:00:00.000000000 Z
-dependencies: []
+date: 2022-05-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 description: A simple and composable event library
 email: mat@blocknot.es
 executables: []
@@ -22,7 +36,10 @@ files:
 - lib/eventish/active_job_event.rb
 - lib/eventish/active_record/callback.rb
 - lib/eventish/adapters/active_support.rb
+- lib/eventish/adapters/wisper.rb
 - lib/eventish/event_api.rb
+- lib/eventish/plugins/logger.rb
+- lib/eventish/plugins/rails_logger.rb
 - lib/eventish/simple_event.rb
 - lib/eventish/version.rb
 homepage: https://github.com/blocknotes/eventish