active_delivery 1.0.0.rc2 → 1.1.0

data/lib/.rbnext/3.0/active_delivery/base.rb

@@ -1,6 +1,38 @@
 # frozen_string_literal: true
 
 module ActiveDelivery
+  class Delivery # :nodoc:
+    attr_reader :params, :options, :metadata, :notification, :owner
+
+    def initialize(owner, notification:, params:, options:, metadata:)
+      @owner = owner
+      @notification = notification
+      @params = params.freeze
+      @options = options.freeze
+      @metadata = metadata.freeze
+    end
+
+    def deliver_later(**opts) ;  owner.perform_notify(self, enqueue_options: opts); end
+
+    def deliver_now(**opts) ;  owner.perform_notify(self, sync: true); end
+
+    def delivery_class ;  owner.class; end
+  end
+
+  class << self
+    # Whether to memoize resolved handler classes or not.
+    # Set to false if you're using a code reloader (e.g., Zeitwerk).
+    #
+    # Defaults to true (i.e. memoization is enabled
+    attr_accessor :cache_classes
+    # Whether to enforce specifying available delivery actions via .delivers in the
+    # delivery classes
+    attr_accessor :deliver_actions_required
+  end
+
+  self.cache_classes = true
+  self.deliver_actions_required = false
+
   # Base class for deliveries.
   #
   # Delivery object describes how to notify a user about
@@ -10,6 +42,8 @@ module ActiveDelivery
   # (i.e. mailers, notifiers). That means that calling a method on delivery class invokes the
   # same method on the corresponding class, e.g.:
   #
+  #   EventsDelivery.one_hour_before(profile, event).deliver_later
+  #   # or
   #   EventsDelivery.notify(:one_hour_before, profile, event)
   #
   #   # under the hood it calls
@@ -20,14 +54,14 @@ module ActiveDelivery
   #
   # Delivery also supports _parameterized_ calling:
   #
-  #   EventsDelivery.with(profile: profile).notify(:canceled, event)
+  #   EventsDelivery.with(profile: profile).canceled(event).deliver_later
   #
   # The parameters could be accessed through `params` instance method (e.g.
   # to implement guard-like logic).
   #
   # When params are presents the parametrized mailer is used, i.e.:
   #
-  #   EventsMailer.with(profile: profile).canceled(event)
+  #   EventsMailer.with(profile: profile).canceled(event).deliver_later
   #
   # See https://api.rubyonrails.org/classes/ActionMailer/Parameterized.html
   class Base
@@ -47,6 +81,8 @@ module ActiveDelivery
         notify(mid, *args, **hargs, sync: true)
       end
 
+      alias_method :notify_now, :notify!
+
       def delivery_lines
         @lines ||= if superclass.respond_to?(:delivery_lines)
           superclass.delivery_lines.each_with_object({}) do |(key, val), acc|
@@ -57,12 +93,19 @@ module ActiveDelivery
         end
       end
 
-      def register_line(line_id, line_class, **options)
+      def register_line(line_id, line_class = nil, notifier: nil, **options)
+        raise ArgumentError, "A line class or notifier configuration must be provided" if line_class.nil? && notifier.nil?
+
+        # Configure Notifier
+        if line_class.nil?
+          line_class = ActiveDelivery::Lines::Notifier
+        end
+
         delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **options)
 
         instance_eval <<~CODE, __FILE__, __LINE__ + 1
           def #{line_id}(val)
-            delivery_lines[:#{line_id}].handler_class = val
+            delivery_lines[:#{line_id}].handler_class_name = val
           end
 
           def #{line_id}_class
@@ -81,8 +124,46 @@ module ActiveDelivery
       end
 
       def abstract_class? ;  abstract_class == true; end
+
+      # Specify explicitly which actions are supported by the delivery.
+      def delivers(*actions)
+        actions.each do |mid|
+          class_eval <<~CODE, __FILE__, __LINE__ + 1
+            def self.#{mid}(...)
+              new.#{mid}(...)
+            end
+
+            def #{mid}(*args, **kwargs)
+              delivery(
+                notification: :#{mid},
+                params: args,
+                options: kwargs
+              )
+            end
+          CODE
+        end
+      end
+
+      def respond_to_missing?(mid, include_private = false)
+        unless ActiveDelivery.deliver_actions_required
+          return true if delivery_lines.any? { |_, line| line.notify?(mid) }
+        end
+
+        super
+      end
+
+      def method_missing(mid, *args, **kwargs)
+        return super unless respond_to_missing?(mid)
+
+        # Lazily define a class method to avoid lookups
+        delivers(mid)
+
+        public_send(mid, *args, **kwargs)
+      end
     end
 
+    self.abstract_class = true
+
     attr_reader :params, :notification_name
 
     def initialize(**params)
@@ -91,31 +172,75 @@ module ActiveDelivery
     end
 
     # Enqueues delivery (i.e. uses #deliver_later for mailers)
-    def notify(mid, *__rest__, &__block__)
-      @notification_name = mid
-      do_notify(*__rest__, &__block__)
-    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify)
+    def notify(mid, *args, **kwargs)
+      perform_notify(
+        delivery(notification: mid, params: args, options: kwargs)
+      )
+    end
 
     # The same as .notify but delivers synchronously
     # (i.e. #deliver_now for mailers)
-    def notify!(mid, *args, **hargs)
-      notify(mid, *args, **hargs, sync: true)
+    def notify!(mid, *args, **kwargs)
+      perform_notify(
+        delivery(notification: mid, params: args, options: kwargs),
+        sync: true
+      )
     end
 
-    private
+    alias_method :notify_now, :notify!
+
+    def respond_to_missing?(mid, include_private = false)
+      unless ActiveDelivery.deliver_actions_required
+        return true if delivery_lines.any? { |_, line| line.notify?(mid) }
+      end
+
+      super
+    end
 
-    def do_notify(*args, sync: false, **kwargs)
+    def method_missing(mid, *args, **kwargs)
+      return super unless respond_to_missing?(mid)
+
+      # Lazily define a method to avoid future lookups
+      self.class.class_eval <<~CODE, __FILE__, __LINE__ + 1
+        def #{mid}(*args, **kwargs)
+          delivery(
+            notification: :#{mid},
+            params: args,
+            options: kwargs
+          )
+        end
+      CODE
+
+      public_send(mid, *args, **kwargs)
+    end
+
+    protected
+
+    def perform_notify(delivery, sync: false, enqueue_options: {})
       delivery_lines.each do |type, line|
-        next if line.handler_class.nil?
-        next unless line.notify?(notification_name)
+        next unless line.notify?(delivery.notification)
 
-        notify_line(type, *args, params: params, sync: sync, **kwargs)
+        notify_line(type, line, delivery, sync: sync, enqueue_options: enqueue_options)
       end
     end
 
-    def notify_line(type, *__rest__, &__block__)
-      delivery_lines[type].notify(notification_name, *__rest__, &__block__)
-    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_line)
+    private
+
+    def notify_line(type, line, delivery, sync:, enqueue_options:)
+      line.notify(
+        delivery.notification,
+        *delivery.params,
+        params: params,
+        sync: sync,
+        enqueue_options: enqueue_options,
+        **delivery.options
+      )
+      true
+    end
+
+    def delivery(notification:, params: nil, options: nil, metadata: nil)
+      Delivery.new(self, notification: notification, params: params, options: options, metadata: metadata)
+    end
 
     def delivery_lines
       self.class.delivery_lines

data/lib/.rbnext/3.0/active_delivery/callbacks.rb

@@ -37,9 +37,11 @@ module ActiveDelivery
     end
 
     module InstanceExt
-      def do_notify(...)
-        run_callbacks(:notify) { super(...) }
-      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :do_notify)
+      def perform_notify(delivery, *__rest__, &__block__)
+        # We need to store the notification name to be able to use it in callbacks if/unless
+        @notification_name = delivery.notification
+        run_callbacks(:notify) { super(delivery, *__rest__, &__block__) }
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :perform_notify)
 
       def notify_line(kind, *__rest__, &__block__)
         run_callbacks(kind) { super(kind, *__rest__, &__block__) }
@@ -73,22 +75,24 @@ module ActiveDelivery
           skip_after_callbacks_if_terminated: true
       end
 
-      def before_notify(method_or_block = nil, on: :notify, **options, &block)
-        method_or_block ||= block
-        _normalize_callback_options(options)
-        set_callback on, :before, method_or_block, options
-      end
+      %i[before after around].each do |kind|
+        define_method "#{kind}_notify" do |*names, on: :notify, **options, &block|
+          _normalize_callback_options(options)
 
-      def after_notify(method_or_block = nil, on: :notify, **options, &block)
-        method_or_block ||= block
-        _normalize_callback_options(options)
-        set_callback on, :after, method_or_block, options
-      end
+          names.each do |name|
+            set_callback on, kind, name, options
+          end
+
+          set_callback on, kind, block, options if block
+        end
+
+        define_method "skip_#{kind}_notify" do |*names, on: :notify, **options|
+          _normalize_callback_options(options)
 
-      def around_notify(method_or_block = nil, on: :notify, **options, &block)
-        method_or_block ||= block
-        _normalize_callback_options(options)
-        set_callback on, :around, method_or_block, options
+          names.each do |name|
+            skip_callback(on, kind, name, options)
+          end
+        end
       end
     end
   end

data/lib/.rbnext/3.0/active_delivery/lines/base.rb

@@ -1,17 +1,22 @@
 # frozen_string_literal: true
 
+unless "".respond_to?(:safe_constantize)
+  require "active_delivery/ext/string_constantize"
+  using ActiveDelivery::Ext::StringConstantize
+end
+
 module ActiveDelivery
   module Lines
     class Base
       attr_reader :id, :options
       attr_accessor :owner
-      attr_writer :handler_class
+      attr_accessor :handler_class_name
 
       def initialize(id:, owner:, **options)
         @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)
@@ -23,7 +28,7 @@ module ActiveDelivery
       end
 
       def notify?(method_name)
-        handler_class.respond_to?(method_name)
+        handler_class&.respond_to?(method_name)
       end
 
       def notify_now(handler, mid, *__rest__, &__block__)
@@ -32,32 +37,65 @@ module ActiveDelivery
       def notify_later(handler, mid, *__rest__, &__block__)
       end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later)
 
-      def notify(mid, *args, params:, sync:, **kwargs)
+      def notify_later_with_options(handler, enqueue_options, mid, *__rest__, &__block__)
+        notify_later(handler, mid, *__rest__, &__block__)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later_with_options)
+
+      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
-        return @handler_class if instance_variable_defined?(:@handler_class)
+        if ::ActiveDelivery.cache_classes
+          return @handler_class if instance_variable_defined?(:@handler_class)
+        end
 
         return @handler_class = nil if owner.abstract_class?
 
-        @handler_class = resolve_class(owner.name) ||
-          superclass_handler
+        superline = owner.superclass.delivery_lines[id] if owner.superclass.respond_to?(:delivery_lines) && owner.superclass.delivery_lines[id]
+
+        # If an explicit class name has been specified somewhere in the ancestor chain, use it.
+        class_name = @handler_class_name || superline&.handler_class_name
+
+        @handler_class =
+          if class_name
+            class_name.is_a?(Class) ? class_name : class_name.safe_constantize
+          else
+            resolve_class(owner) || superline&.handler_class
+          end
       end
 
       private
 
-      def superclass_handler
-        handler_method = "#{id}_class"
+      attr_reader :resolver
 
-        return if owner.superclass == ActiveDelivery::Base
-        return unless owner.superclass.respond_to?(handler_method)
+      def build_pattern_resolver(pattern)
+        return unless pattern
 
-        owner.superclass.public_send(handler_method)
-      end
+        proc do |delivery|
+          delivery_class = delivery.name
 
-      attr_reader :resolver
+          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_class, delivery_name: delivery_name, delivery_namespace: delivery_namespace}).safe_constantize
+        end
+      end
     end
   end
 end

data/lib/.rbnext/3.0/active_delivery/lines/mailer.rb

@@ -5,9 +5,10 @@ module ActiveDelivery
     class Mailer < Base
       alias_method :mailer_class, :handler_class
 
-      DEFAULT_RESOLVER = ->(name) { name.gsub(/Delivery$/, "Mailer").safe_constantize }
+      DEFAULT_RESOLVER = ->(klass) { klass.name&.gsub(/Delivery$/, "Mailer")&.safe_constantize }
 
       def notify?(method_name)
+        return unless mailer_class
         mailer_class.action_methods.include?(method_name.to_s)
       end
 
@@ -18,6 +19,10 @@ module ActiveDelivery
       def notify_later(mailer, mid, *__rest__, &__block__)
         mailer.public_send(mid, *__rest__, &__block__).deliver_later
       end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later)
+
+      def notify_later_with_options(mailer, enqueue_options, mid, *__rest__, &__block__)
+        mailer.public_send(mid, *__rest__, &__block__).deliver_later(**enqueue_options)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later_with_options)
     end
 
     ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER

data/lib/.rbnext/3.0/active_delivery/testing.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module TestDelivery
+    class << self
+      def enable
+        raise ArgumentError, "block is required" unless block_given?
+        begin
+          clear
+          Thread.current.thread_variable_set(:active_delivery_testing, true)
+          yield
+        ensure
+          Thread.current.thread_variable_set(:active_delivery_testing, false)
+        end
+      end
+
+      def enabled?
+        Thread.current.thread_variable_get(:active_delivery_testing) == true
+      end
+
+      def track(delivery, options)
+        store << [delivery, options]
+      end
+
+      def track_line(line)
+        lines << line
+      end
+
+      def store
+        Thread.current.thread_variable_get(:active_delivery_testing_store) || Thread.current.thread_variable_set(:active_delivery_testing_store, [])
+      end
+
+      def lines
+        Thread.current.thread_variable_get(:active_delivery_testing_lines) || Thread.current.thread_variable_set(:active_delivery_testing_lines, [])
+      end
+
+      def clear
+        store.clear
+        lines.clear
+      end
+    end
+
+    def perform_notify(delivery, **options)
+      return super unless test?
+      TestDelivery.track(delivery, options)
+      nil
+    end
+
+    def notify_line(line, *__rest__, &__block__)
+      res = super
+      TestDelivery.track_line(line) if res
+    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_line)
+
+    def test?
+      TestDelivery.enabled?
+    end
+  end
+end
+
+ActiveDelivery::Base.prepend ActiveDelivery::TestDelivery
+
+require "active_delivery/testing/rspec" if defined?(RSpec::Core)

data/lib/.rbnext/3.1/abstract_notifier/async_adapters/active_job.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  module AsyncAdapters
+    class ActiveJob
+      class DeliveryJob < ::ActiveJob::Base
+        def perform(notifier_class, ...)
+          AbstractNotifier::NotificationDelivery.new(notifier_class.constantize, ...).notify_now
+        end
+      end
+
+      DEFAULT_QUEUE = "notifiers"
+
+      attr_reader :job, :queue
+
+      def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
+        @job = job
+        @queue = queue
+      end
+
+      def enqueue(...)
+        job.set(queue: queue).perform_later(...)
+      end
+
+      def enqueue_delivery(delivery, **opts)
+        job.set(queue: queue, **opts).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
+      end
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job