active_delivery 1.0.0.rc2 → 1.1.0

data/lib/abstract_notifier/base.rb

@@ -1,25 +1,59 @@
 # frozen_string_literal: true
 
 module AbstractNotifier
-  # Notificaiton payload wrapper which contains
+  # NotificationDelivery payload wrapper which contains
   # information about the current notifier class
   # and knows how to trigger the delivery
-  class Notification
-    attr_reader :payload, :owner
+  class NotificationDelivery
+    attr_reader :action_name, :notifier_class
+
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
+      @action_name = action_name
+      @params = params
+      @args = args
+      @kwargs = kwargs
+    end
 
-    def initialize(owner, payload)
-      @owner = owner
-      @payload = payload
+    def processed
+      return @processed if instance_variable_defined?(:@processed)
+
+      @processed = notifier.process_action(action_name, *args, **kwargs) || Notification.new(nil)
     end
 
-    def notify_later
-      return if AbstractNotifier.noop?
-      owner.async_adapter.enqueue owner, payload
+    alias_method :notification, :processed
+
+    def notify_later(**opts)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **opts)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params:, args:, kwargs:)
+      end
     end
 
     def notify_now
-      return if AbstractNotifier.noop?
-      owner.driver.call(payload)
+      return unless notification.payload
+
+      notifier.deliver!(notification)
+    end
+
+    def delivery_params = {params:, args:, kwargs:}
+
+    private
+
+    attr_reader :params, :args, :kwargs
+
+    def notifier
+      @notifier ||= notifier_class.new(action_name, **params)
+    end
+  end
+
+  # Notification object contains the compiled payload to be delivered
+  class Notification
+    attr_reader :payload
+
+    def initialize(payload)
+      @payload = payload
     end
   end
 
@@ -35,11 +69,7 @@ module AbstractNotifier
 
       # rubocop:disable Style/MethodMissingSuper
       def method_missing(method_name, *args, **kwargs)
-        if kwargs.empty?
-          notifier_class.new(method_name, **params).public_send(method_name, *args)
-        else
-          notifier_class.new(method_name, **params).public_send(method_name, *args, **kwargs)
-        end
+        NotificationDelivery.new(notifier_class, method_name, params:, args:, kwargs:)
       end
       # rubocop:enable Style/MethodMissingSuper
 
@@ -112,9 +142,9 @@ module AbstractNotifier
           end
       end
 
-      def method_missing(method_name, *args)
+      def method_missing(method_name, *args, **kwargs)
         if action_methods.include?(method_name.to_s)
-          new(method_name).public_send(method_name, *args)
+          NotificationDelivery.new(self, method_name, args:, kwargs:)
         else
           super
         end
@@ -152,16 +182,31 @@ module AbstractNotifier
       @params = params.freeze
     end
 
+    def process_action(...)
+      public_send(...)
+    end
+
+    def deliver!(notification)
+      self.class.driver.call(notification.payload)
+    end
+
     def notification(**payload)
       merge_defaults!(payload)
 
+      payload[:body] = implicit_payload_body unless payload.key?(:body)
+
       raise ArgumentError, "Notification body must be present" if
         payload[:body].nil? || payload[:body].empty?
-      Notification.new(self.class, payload)
+
+      @notification = Notification.new(payload)
     end
 
     private
 
+    def implicit_payload_body
+      # no-op — override to provide custom logic
+    end
+
     def merge_defaults!(payload)
       defaults =
         if self.class.defaults_generator

data/lib/abstract_notifier/callbacks.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "active_support/version"
+require "active_support/callbacks"
+require "active_support/concern"
+
+module AbstractNotifier
+  # Add callbacks support to Abstract Notifier (requires ActiveSupport::Callbacks)
+  #
+  #   # Run method before seding notification
+  #   # NOTE: when `false` is returned the execution is halted
+  #   before_action :do_something
+  #
+  #   # after_ and around_ callbacks are also supported
+  #   after_action :cleanup
+  #
+  #   around_action :set_context
+  #
+  #   # Deliver callbacks are also available
+  #   before_deliver :do_something
+  #
+  #   # after_ and around_ callbacks are also supported
+  #   after_deliver :cleanup
+  #
+  #   around_deliver :set_context
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Callbacks
+
+    CALLBACK_TERMINATOR = ->(_target, result) { result.call == false }
+
+    included do
+      define_callbacks :action,
+        terminator: CALLBACK_TERMINATOR,
+        skip_after_callbacks_if_terminated: true
+
+      define_callbacks :deliver,
+        terminator: CALLBACK_TERMINATOR,
+        skip_after_callbacks_if_terminated: true
+
+      prepend InstanceExt
+    end
+
+    module InstanceExt
+      def process_action(...)
+        run_callbacks(:action) { super(...) }
+      end
+
+      def deliver!(...)
+        run_callbacks(:deliver) { super(...) }
+      end
+    end
+
+    class_methods do
+      def _normalize_callback_options(options)
+        _normalize_callback_option(options, :only, :if)
+        _normalize_callback_option(options, :except, :unless)
+      end
+
+      def _normalize_callback_option(options, from, to)
+        if (from = options[from])
+          from_set = Array(from).map(&:to_s).to_set
+          from = proc { |c| from_set.include? c.notification_name.to_s }
+          options[to] = Array(options[to]).unshift(from)
+        end
+      end
+
+      %i[before after around].each do |kind|
+        %i[action deliver].each do |event|
+          define_method "#{kind}_#{event}" do |*names, on: event, **options, &block|
+            _normalize_callback_options(options)
+
+            names.each do |name|
+              set_callback on, kind, name, options
+            end
+
+            set_callback on, kind, block, options if block
+          end
+
+          define_method "skip_#{kind}_#{event}" do |*names, on: event, **options|
+            _normalize_callback_options(options)
+
+            names.each do |name|
+              skip_callback(on, kind, name, options)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+AbstractNotifier::Base.include AbstractNotifier::Callbacks

data/lib/abstract_notifier/testing.rb

@@ -27,23 +27,27 @@ module AbstractNotifier
       end
     end
 
-    module Notification
+    module NotificationDelivery
       def notify_now
         return super unless AbstractNotifier.test?
 
-        Driver.send_notification payload.merge(via: owner)
+        payload = notification.payload
+
+        Driver.send_notification payload.merge(via: notifier.class)
       end
 
-      def notify_later
+      def notify_later(**opts)
         return super unless AbstractNotifier.test?
 
-        Driver.enqueue_notification payload.merge(via: owner)
+        payload = notification.payload
+
+        Driver.enqueue_notification payload.merge(via: notifier.class, **opts)
       end
     end
   end
 end
 
-AbstractNotifier::Notification.prepend AbstractNotifier::Testing::Notification
+AbstractNotifier::NotificationDelivery.prepend AbstractNotifier::Testing::NotificationDelivery
 
 require "abstract_notifier/testing/rspec" if defined?(RSpec::Core)
 require "abstract_notifier/testing/minitest" if defined?(Minitest::Assertions)

data/lib/abstract_notifier/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module AbstractNotifier
-  VERSION = "0.3.2"
+  VERSION = "1.0.0"
 end

data/lib/abstract_notifier.rb

@@ -69,6 +69,7 @@ end
 require "abstract_notifier/base"
 require "abstract_notifier/async_adapters"
 
+require "abstract_notifier/callbacks" if defined?(ActiveSupport)
 require "abstract_notifier/async_adapters/active_job" if defined?(ActiveJob)
 
 require "abstract_notifier/testing" if ENV["RACK_ENV"] == "test" || ENV["RAILS_ENV"] == "test"

data/lib/active_delivery/base.rb

@@ -12,9 +12,9 @@ module ActiveDelivery
       @metadata = metadata.freeze
     end
 
-    def deliver_later = owner.perform_notify(self)
+    def deliver_later(**opts) = owner.perform_notify(self, enqueue_options: opts)
 
-    def deliver_now = owner.perform_notify(self, sync: true)
+    def deliver_now(**opts) = owner.perform_notify(self, sync: true)
 
     def delivery_class = owner.class
   end
@@ -216,22 +216,23 @@ module ActiveDelivery
 
     protected
 
-    def perform_notify(delivery, sync: false)
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
         next unless line.notify?(delivery.notification)
 
-        notify_line(type, line, delivery, sync:)
+        notify_line(type, line, delivery, sync:, enqueue_options:)
       end
     end
 
     private
 
-    def notify_line(type, line, delivery, sync:)
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
       line.notify(
         delivery.notification,
         *delivery.params,
         params:,
         sync:,
+        enqueue_options:,
         **delivery.options
       )
       true

data/lib/active_delivery/lines/base.rb

@@ -16,7 +16,7 @@ module ActiveDelivery
         @id = id
         @owner = owner
         @options = options.tap(&:freeze)
-        @resolver = options[:resolver]
+        @resolver = options[:resolver] || build_pattern_resolver(options[:resolver_pattern])
       end
 
       def dup_for(new_owner)
@@ -37,9 +37,21 @@ module ActiveDelivery
       def notify_later(handler, mid, ...)
       end
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, ...)
+        notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *args, params:, sync:, enqueue_options:, **kwargs)
         clazz = params.empty? ? handler_class : handler_class.with(**params)
-        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+        if sync
+          return notify_now(clazz, mid, *args, **kwargs)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *args, **kwargs)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *args, **kwargs)
+        end
       end
 
       def handler_class
@@ -65,6 +77,25 @@ module ActiveDelivery
       private
 
       attr_reader :resolver
+
+      def build_pattern_resolver(pattern)
+        return unless pattern
+
+        proc do |delivery|
+          delivery_class = delivery.name
+
+          next unless delivery_class
+
+          *namespace, delivery_name = delivery_class.split("::")
+
+          delivery_namespace = ""
+          delivery_namespace = "#{namespace.join("::")}::" unless namespace.empty?
+
+          delivery_name = delivery_name.sub(/Delivery$/, "")
+
+          (pattern % {delivery_class:, delivery_name:, delivery_namespace:}).safe_constantize
+        end
+      end
     end
   end
 end

data/lib/active_delivery/lines/mailer.rb

@@ -19,6 +19,10 @@ module ActiveDelivery
       def notify_later(mailer, mid, ...)
         mailer.public_send(mid, ...).deliver_later
       end
+
+      def notify_later_with_options(mailer, enqueue_options, mid, ...)
+        mailer.public_send(mid, ...).deliver_later(**enqueue_options)
+      end
     end
 
     ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER

data/lib/active_delivery/lines/notifier.rb

@@ -18,7 +18,7 @@ module ActiveDelivery
 
       def initialize(**opts)
         super
-        @resolver = opts.fetch(:resolver, build_resolver(options.fetch(:suffix, DEFAULT_SUFFIX)))
+        @resolver ||= build_resolver(options.fetch(:suffix, DEFAULT_SUFFIX))
       end
 
       def resolve_class(klass)
@@ -38,6 +38,10 @@ module ActiveDelivery
         handler.public_send(mid, *args).notify_later
       end
 
+      def notify_later_with_options(handler, enqueue_options, mid, *args)
+        handler.public_send(mid, *args).notify_later(**enqueue_options)
+      end
+
       private
 
       attr_reader :resolver

data/lib/active_delivery/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveDelivery
-  VERSION = "1.0.0.rc2"
+  VERSION = "1.1.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_delivery
 version: !ruby/object:Gem::Version
-  version: 1.0.0.rc2
+  version: 1.1.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-05 00:00:00.000000000 Z
+date: 2023-12-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,7 +67,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
-  name: ruby-next
+  name: ruby-next-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -93,16 +93,22 @@ files:
 - README.md
 - bin/console
 - bin/setup
+- lib/.rbnext/3.0/abstract_notifier/async_adapters/active_job.rb
+- lib/.rbnext/3.0/abstract_notifier/base.rb
 - lib/.rbnext/3.0/active_delivery/base.rb
 - lib/.rbnext/3.0/active_delivery/callbacks.rb
 - lib/.rbnext/3.0/active_delivery/lines/base.rb
 - lib/.rbnext/3.0/active_delivery/lines/mailer.rb
+- lib/.rbnext/3.0/active_delivery/testing.rb
+- lib/.rbnext/3.1/abstract_notifier/async_adapters/active_job.rb
+- lib/.rbnext/3.1/abstract_notifier/base.rb
 - lib/.rbnext/3.1/active_delivery/base.rb
 - lib/.rbnext/3.1/active_delivery/lines/base.rb
 - lib/abstract_notifier.rb
 - lib/abstract_notifier/async_adapters.rb
 - lib/abstract_notifier/async_adapters/active_job.rb
 - lib/abstract_notifier/base.rb
+- lib/abstract_notifier/callbacks.rb
 - lib/abstract_notifier/testing.rb
 - lib/abstract_notifier/testing/minitest.rb
 - lib/abstract_notifier/testing/rspec.rb
@@ -138,11 +144,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
-rubygems_version: 3.4.8
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Ruby and Rails framework for managing all types of notifications in one place