eventish 0.2.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af7a6bf91a4b7cc8af46ea2520aeef223eedcce5cedceac04b7d91cc43333936
-  data.tar.gz: 1ab3f8d60e00c982c3044cf0fc7bf7e53dd1435914238842724d6f2f211698ba
+  metadata.gz: affdd6406fe05bcc51fa60a0bdd1e894c47412e8d8c347e2f8e4e8ed0d846757
+  data.tar.gz: 754e24d0338cb7eb4c6eb299371d2880b0b867a85fadb0b604ea3511a8e9ee32
 SHA512:
-  metadata.gz: dd0f4b9d8d6ec2705bd0d6679296705b5e3838730fc3fbcaa6657490dc6c108db80886cf2399220545b0b374c904da0bd1ac19beaac3e9c7af9a3efb5c625bc9
-  data.tar.gz: e1eb63690fde2b62cbfc0d9c52bb1beea73e03205abffef5aa24de8097c4e935d6ee15c2ee67d19dc6acd46050ef11d8b85b11cbcbd5caa86e24f6199f7c5fe2
+  metadata.gz: 23e2bd4268d4c28a3691327e499552815fbe05d6ada3e17a887e812ec2666d4f65c8c78ac878d7ef0426403cd61760134a06f7c0d9a07da6c8e73fe440da9da0
+  data.tar.gz: 530d9dcd90223304e1606cbfe909ccf223d1353d1409a230807b29cf6258fa740228235975f0411484b99886ab961349a84ca73a3a432842090c7b95d69cf713

data/README.md

@@ -8,7 +8,8 @@ Yet another opinionated events library which proposes a simple API to handle...
 The 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 _async events_: support ActiveJob for background execution;
+- with _callbacks_ wrapper: support ActiveRecord.
 
 ## Install
 
@@ -88,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
@@ -124,6 +124,25 @@ module Notifications
 end
 ```
 
+### Callbacks
+
+Only for ActiveRecord, callbacks wrapper are available with the postfix `_event` (ex. `after_commit_event SomeEvent`).
+
+```rb
+# initializer setup
+require 'eventish/active_record/callback'
+```
+
+```rb
+class SomeModel < ActiveRecord::Base
+  extend ::Eventish::ActiveRecord::Callback
+
+  before_validation_event SomeBeforeValidationEvent
+end
+```
+
+The related callback will be setup by the wrapper and the specified event class will be invoked accordingly.
+
 ## 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_record/callback.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Eventish
+  module ActiveRecord
+    module Callback
+      # Init events
+      def after_initialize_event(event)
+        after_initialize -> { ::Eventish.publish(event, self) }
+      end
+
+      def after_find_event(event)
+        after_find -> { ::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 ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      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 ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      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 ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      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 ->(_object, block) { ::Eventish.publish(event, self, block: block) }
+      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_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_save_commit_event(event)
+        after_save_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.2.0'
+  VERSION = '0.3.2'
 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,25 +18,15 @@ module Eventish
     @options ||= Struct.new(*OPTIONS).new # rubocop:disable Naming/MemoizedInstanceVariableName
   end
 
-  def publish(event_name, target = nil, &block)
-    config.adapter&.publish(event_name, target, &block)
+  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.2.0
+  version: 0.3.2
 platform: ruby
 authors:
 - Mattia Roccoberton
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-05-17 00:00:00.000000000 Z
+date: 2022-05-20 00:00:00.000000000 Z
 dependencies: []
 description: A simple and composable event library
 email: mat@blocknot.es
@@ -20,6 +20,7 @@ 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/event_api.rb
 - lib/eventish/simple_event.rb