eventish 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08c9cf6785fc35a3174bf04df8a3f46011a10f1dc465ed24903d3924c293927a'
-  data.tar.gz: 53efbd04a12d69149c594f375b3b79da0cda0a9ed6a339e09d88ff4a9d4d830b
+  metadata.gz: 8f5572d1bca258f0f1c9bd4e09e3743f99bf3045c82013c9742e1b06cfb3c590
+  data.tar.gz: abe5bdf2cbe1998404c21686ee97758681be8e038c0af03c67b7be1cbed2c8c5
 SHA512:
-  metadata.gz: 3aabb2135effcd4234379ef10beda4cb8cd2a5489b6b7318e7bc9cc84de6ef84daa5972b35496636dc3d439f7829cf2ef3ef27786c7512339a24b87404b4bce8
-  data.tar.gz: 63197732c22986bfc7f9d647808350886b71121cc9ccd3125ba35fa3f6eb3db2cc152b36c4f0fbd347224c46b9be50381a18e595014088341879769590593535
+  metadata.gz: 885eb9228852f4d143a52ca2db3b622eead0bb9c57bc47fecb8ce29ce9694488973151a1bcaf07df2783192aa362dd3626c200ca36a39afc721a6f5c22cc6222
+  data.tar.gz: e86ca0a3133a144c709a3a1cc76b2ba777d5995a8068ba202b6570bc4c31ab14e73fea390e3898825276bbc97651dfcdecb978af2266880f47219e810fc00d03

data/README.md

@@ -1,12 +1,15 @@
 # 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)
+
 Yet another opinionated events library which proposes a simple API to handle... events 🎉
 
 The main features:
-- composable: just require the components that you need;
-- with adapters: support _ActiveSupport::Notifications_;
-- with async events: support _ActiveJob_;
-- with callbacks: support _ActiveRecord_.
+- _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.
 
 ## Install
 
@@ -31,7 +34,7 @@ end
 Rails.configuration.after_initialize do
   Eventish::SimpleEvent.subscribe_all # NOTE: events will be available after this point
 
-  Eventish.adapter.publish('app_loaded') # just a test event
+  Eventish.publish('app_loaded') # just a test event
 end
 ```
 
@@ -86,8 +89,7 @@ module Main
 
     class << self
       def event_name
-        # this is optional, if not set the event name will be inferred from the class name
-        # in this sample it would be "test" - TestEvent => underscore => remove _event suffix
+        # this is optional, if not set the class name to string will be used
         'some_event'
       end
     end
@@ -95,7 +97,7 @@ module Main
 end
 ```
 
-Publish the event: `Eventish.adapter.publish('some_event')`
+Publish the event: `Eventish.publish('some_event')`
 
 ### Async events
 
@@ -124,24 +126,22 @@ end
 
 ### Callbacks
 
-Wrapper for callbacks. Only _ActiveRecord_ is supported for now.
-This is just a glue component to have callbacks with a nice syntax.
+Only for ActiveRecord, callbacks wrapper are available with the postfix `_event` (ex. `after_commit_event SomeEvent`).
 
 ```rb
 # initializer setup
-require 'eventish/callback'
+require 'eventish/active_record/callback'
 ```
 
-Sample model usage:
-
 ```rb
-class User < ActiveRecord::Base
-  before_validation ::Eventish::Callback
-  after_save_commit ::Eventish::Callback
+class SomeModel < ActiveRecord::Base
+  extend ::Eventish::ActiveRecord::Callback
+
+  before_validation_event SomeBeforeValidationEvent
 end
 ```
 
-For events definition see Simple or Async events.
+The related callback will be setup by the wrapper and the specified event class will be invoked accordingly.
 
 ## Do you like it? Star it!
 

data/lib/eventish/active_record/callback.rb

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

data/lib/eventish/adapters/active_support.rb

@@ -4,19 +4,27 @@ module Eventish
   class Adapters
     class ActiveSupport
       class << self
-        def publish(event_name, target = nil, options: {})
-          ::ActiveSupport::Notifications.instrument(event_name, target: target, event_options: options)
+        def publish(event, target = nil, block: nil)
+          raise ArgumentError, 'Missing event to publish' if event.nil?
+
+          options = { block: block }
+          ::ActiveSupport::Notifications.instrument(event.to_s, target: target, options: options)
         end
 
-        def subscribe(event_name, handler)
-          ::ActiveSupport::Notifications.subscribe(event_name) do |name, start, finish, id, payload|
+        def subscribe(event, handler)
+          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|
             args = { event: name, id: id, start: start, finish: finish }
-            handler.trigger(payload[:target], args, &payload[:block])
+            handler.trigger(payload[:target], args, &payload.dig(:options, :block))
           end
         end
 
-        def unsubscribe(event_name)
-          ::ActiveSupport::Notifications.unsubscribe(event_name)
+        def unsubscribe(event)
+          raise ArgumentError, 'Missing event to unsubscribe' if event.nil?
+
+          ::ActiveSupport::Notifications.unsubscribe(event.to_s)
         end
       end
     end

data/lib/eventish/event_api.rb

@@ -7,8 +7,7 @@ module Eventish
     end
 
     def event_name
-      # If event_name is not set, infer the event from the class name
-      @event_name ||= Eventish.underscore(to_s).delete_suffix('_event')
+      @event_name ||= to_s
     end
 
     def priority

data/lib/eventish/version.rb

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

data/lib/eventish.rb

@@ -6,7 +6,7 @@ require_relative 'eventish/simple_event'
 module Eventish
   OPTIONS = %i[adapter].freeze
 
-  MissingAdapterError = Class.new(StandardError)
+  AdapterError = Class.new(StandardError)
 
   module_function
 
@@ -18,21 +18,15 @@ module Eventish
     @options ||= Struct.new(*OPTIONS).new # rubocop:disable Naming/MemoizedInstanceVariableName
   end
 
+  def publish(event_name, target = nil, block: nil)
+    config.adapter&.publish(event_name, target, block: block)
+  end
+
   def setup
     @options ||= Struct.new(*OPTIONS).new
     yield(@options) if block_given?
-    raise MissingAdapterError, 'Please specify an event adapter' unless @options.adapter
+    raise AdapterError, 'Please specify an event adapter' unless @options.adapter
 
     @options
   end
-
-  def underscore(camel_cased_word)
-    return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
-
-    word = camel_cased_word.to_s.gsub(/\A.*::/, '')
-    word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
-    word.tr!("-", "_")
-    word.downcase!
-    word
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eventish
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-17 00:00:00.000000000 Z
+date: 2022-05-19 00:00:00.000000000 Z
 dependencies: []
 description: A simple and composable event library
 email: mat@blocknot.es
@@ -20,8 +20,8 @@ files:
 - README.md
 - lib/eventish.rb
 - lib/eventish/active_job_event.rb
+- lib/eventish/active_record/callback.rb
 - lib/eventish/adapters/active_support.rb
-- lib/eventish/callback.rb
 - lib/eventish/event_api.rb
 - lib/eventish/simple_event.rb
 - lib/eventish/version.rb

data/lib/eventish/callback.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-module Eventish
-  class Callback
-    class << self
-      def callback_event(target, &block)
-        event = "#{Eventish.underscore(target.class.to_s)}_#{__callee__}"
-        Eventish.adapter.publish(event, target, &block)
-      end
-
-      def callback_commit_event(target, &block)
-        event = "#{Eventish.underscore(target.class.to_s)}_after_commit"
-        Eventish.adapter.publish(event, target, &block)
-      end
-
-      alias_method :after_initialize, :callback_event
-      alias_method :after_find, :callback_event
-
-      alias_method :before_validation, :callback_event
-      alias_method :after_validation, :callback_event
-
-      alias_method :before_create, :callback_event
-      alias_method :around_create, :callback_event
-      alias_method :after_create, :callback_event
-
-      alias_method :before_update, :callback_event
-      alias_method :around_update, :callback_event
-      alias_method :after_update, :callback_event
-
-      alias_method :before_save, :callback_event
-      alias_method :around_save, :callback_event
-      alias_method :after_save, :callback_event
-
-      alias_method :before_destroy, :callback_event
-      alias_method :around_destroy, :callback_event
-      alias_method :after_destroy, :callback_event
-
-      alias_method :after_commit, :callback_commit_event
-      alias_method :after_save_commit, :callback_commit_event # => after_commit
-      alias_method :after_create_commit, :callback_commit_event # => after_commit
-      alias_method :after_update_commit, :callback_commit_event # => after_commit
-      alias_method :after_destroy_commit, :callback_commit_event # => after_commit
-      alias_method :after_rollback, :callback_event
-
-      alias_method :after_touch, :callback_event
-    end
-  end
-end