active_delivery 1.0.0 → 1.2.0

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module TestHelper
+    def assert_deliveries(count)
+      TestDelivery.enable { yield }
+
+      assert_equal TestDelivery.store.count, count, "Expected #{count} deliveries, got #{TestDelivery.store.count}"
+    end
+
+    def assert_no_deliveries(&__block__) ;  assert_deliveries(0, &__block__); end
+
+    def assert_delivery_enqueued(delivery_class, event, count: 1, params: nil, with: nil)
+      TestDelivery.enable { yield }
+
+      deliveries = TestDelivery.store
+
+      if with
+        args = with
+        kwargs = args.pop if args.last.is_a?(Hash)
+      end
+
+      matching_deliveries, _unmatching_deliveries =
+        deliveries.partition do |(delivery, options)|
+          next false if delivery_class != delivery.owner.class
+
+          next false if event != delivery.notification
+
+          next false if params && !hash_include?(delivery.owner.params, params)
+
+          next true unless with
+
+          actual_args = delivery.params
+          actual_kwargs = delivery.options
+
+          next false unless args.each.with_index.all? do |arg, i|
+            arg === actual_args[i]
+          end
+
+          next false unless kwargs.all? do |k, v|
+            v === actual_kwargs[k]
+          end
+
+          true
+        end
+
+      assert_equal count, matching_deliveries.count, "Expected #{count} deliveries, got #{deliveries.count}"
+    end
+
+    private
+
+    def hash_include?(haystack, needle)
+      needle.all? do |k, v|
+        haystack.key?(k) && haystack[k] == v
+      end
+    end
+  end
+end

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

@@ -60,3 +60,4 @@ end
 ActiveDelivery::Base.prepend ActiveDelivery::TestDelivery
 
 require "active_delivery/testing/rspec" if defined?(RSpec::Core)
+require "active_delivery/testing/minitest" if defined?(Minitest::Assertions)

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, **__kwrest__)
+        job.set(queue: queue, **__kwrest__).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
+      end
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job

data/lib/.rbnext/3.1/abstract_notifier/base.rb

@@ -5,10 +5,10 @@ module AbstractNotifier
   # information about the current notifier class
   # and knows how to trigger the delivery
   class NotificationDelivery
-    attr_reader :action_name
+    attr_reader :action_name, :notifier_class
 
-    def initialize(owner_class, action_name, params: {}, args: [], kwargs: {})
-      @owner_class = owner_class
+    def initialize(notifier_class, action_name, params: {}, args: [], kwargs: {})
+      @notifier_class = notifier_class
       @action_name = action_name
       @params = params
       @args = args
@@ -23,8 +23,12 @@ module AbstractNotifier
 
     alias_method :notification, :processed
 
-    def notify_later
-      owner_class.async_adapter.enqueue(owner_class.name, action_name, params: params, args: args, kwargs: kwargs)
+    def notify_later(**__kwrest__)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **__kwrest__)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params: params, args: args, kwargs: kwargs)
+      end
     end
 
     def notify_now
@@ -33,12 +37,14 @@ module AbstractNotifier
       notifier.deliver!(notification)
     end
 
+    def delivery_params ;  {params: params, args: args, kwargs: kwargs}; end
+
     private
 
-    attr_reader :owner_class, :params, :args, :kwargs
+    attr_reader :params, :args, :kwargs
 
     def notifier
-      @notifier ||= owner_class.new(action_name, **params)
+      @notifier ||= notifier_class.new(action_name, **params)
     end
   end
 
@@ -67,8 +73,8 @@ module AbstractNotifier
       end
       # rubocop:enable Style/MethodMissingSuper
 
-      def respond_to_missing?(*args)
-        notifier_class.respond_to_missing?(*args)
+      def respond_to_missing?(*__rest__)
+        notifier_class.respond_to_missing?(*__rest__)
       end
     end
 
@@ -178,7 +184,7 @@ module AbstractNotifier
 
     def process_action(...)
       public_send(...)
-    end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :process_action)
+    end
 
     def deliver!(notification)
       self.class.driver.call(notification.payload)

data/lib/.rbnext/3.1/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
@@ -77,8 +77,8 @@ module ActiveDelivery
 
       # 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, *__rest__, **hargs)
+        notify(mid, *__rest__, **hargs, sync: true)
       end
 
       alias_method :notify_now, :notify!
@@ -93,7 +93,7 @@ module ActiveDelivery
         end
       end
 
-      def register_line(line_id, line_class = nil, notifier: nil, **options)
+      def register_line(line_id, line_class = nil, notifier: nil, **__kwrest__)
         raise ArgumentError, "A line class or notifier configuration must be provided" if line_class.nil? && notifier.nil?
 
         # Configure Notifier
@@ -101,7 +101,7 @@ module ActiveDelivery
           line_class = ActiveDelivery::Lines::Notifier
         end
 
-        delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **options)
+        delivery_lines[line_id] = line_class.new(id: line_id, owner: self, **__kwrest__)
 
         instance_eval <<~CODE, __FILE__, __LINE__ + 1
           def #{line_id}(val)
@@ -152,13 +152,13 @@ module ActiveDelivery
         super
       end
 
-      def method_missing(mid, *args, **kwargs)
+      def method_missing(mid, *__rest__, **__kwrest__)
         return super unless respond_to_missing?(mid)
 
         # Lazily define a class method to avoid lookups
         delivers(mid)
 
-        public_send(mid, *args, **kwargs)
+        public_send(mid, *__rest__, **__kwrest__)
       end
     end
 
@@ -197,7 +197,7 @@ module ActiveDelivery
       super
     end
 
-    def method_missing(mid, *args, **kwargs)
+    def method_missing(mid, *__rest__, **__kwrest__)
       return super unless respond_to_missing?(mid)
 
       # Lazily define a method to avoid future lookups
@@ -211,27 +211,28 @@ module ActiveDelivery
         end
       CODE
 
-      public_send(mid, *args, **kwargs)
+      public_send(mid, *__rest__, **__kwrest__)
     end
 
     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: sync)
+        notify_line(type, line, delivery, sync: sync, enqueue_options: 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: params,
         sync: sync,
+        enqueue_options: enqueue_options,
         **delivery.options
       )
       true

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

@@ -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, *__rest__, params:, sync:, enqueue_options:, **__kwrest__)
         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, *__rest__, **__kwrest__)
+        end
+
+        if enqueue_options.empty?
+          notify_later(clazz, mid, *__rest__, **__kwrest__)
+        else
+          notify_later_with_options(clazz, enqueue_options, mid, *__rest__, **__kwrest__)
+        end
       end
 
       def handler_class

data/lib/.rbnext/3.1/active_delivery/testing/minitest.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module TestHelper
+    def assert_deliveries(count)
+      TestDelivery.enable { yield }
+
+      assert_equal TestDelivery.store.count, count, "Expected #{count} deliveries, got #{TestDelivery.store.count}"
+    end
+
+    def assert_no_deliveries(&__block__) = assert_deliveries(0, &__block__)
+
+    def assert_delivery_enqueued(delivery_class, event, count: 1, params: nil, with: nil)
+      TestDelivery.enable { yield }
+
+      deliveries = TestDelivery.store
+
+      if with
+        args = with
+        kwargs = args.pop if args.last.is_a?(Hash)
+      end
+
+      matching_deliveries, _unmatching_deliveries =
+        deliveries.partition do |(delivery, options)|
+          next false if delivery_class != delivery.owner.class
+
+          next false if event != delivery.notification
+
+          next false if params && !hash_include?(delivery.owner.params, params)
+
+          next true unless with
+
+          actual_args = delivery.params
+          actual_kwargs = delivery.options
+
+          next false unless args.each.with_index.all? do |arg, i|
+            arg === actual_args[i]
+          end
+
+          next false unless kwargs.all? do |k, v|
+            v === actual_kwargs[k]
+          end
+
+          true
+        end
+
+      assert_equal count, matching_deliveries.count, "Expected #{count} deliveries, got #{deliveries.count}"
+    end
+
+    private
+
+    def hash_include?(haystack, needle)
+      needle.all? do |k, v|
+        haystack.key?(k) && haystack[k] == v
+      end
+    end
+  end
+end

data/lib/.rbnext/3.2/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:).perform_later(...)
+      end
+
+      def enqueue_delivery(delivery, **__kwrest__)
+        job.set(queue:, **__kwrest__).perform_later(
+          delivery.notifier_class.name,
+          delivery.action_name,
+          **delivery.delivery_params
+        )
+      end
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job

data/lib/.rbnext/3.2/abstract_notifier/base.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  # NotificationDelivery payload wrapper which contains
+  # information about the current notifier class
+  # and knows how to trigger the delivery
+  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 processed
+      return @processed if instance_variable_defined?(:@processed)
+
+      @processed = notifier.process_action(action_name, *args, **kwargs) || Notification.new(nil)
+    end
+
+    alias_method :notification, :processed
+
+    def notify_later(**__kwrest__)
+      if notifier_class.async_adapter.respond_to?(:enqueue_delivery)
+        notifier_class.async_adapter.enqueue_delivery(self, **__kwrest__)
+      else
+        notifier_class.async_adapter.enqueue(notifier_class.name, action_name, params:, args:, kwargs:)
+      end
+    end
+
+    def notify_now
+      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
+
+  # Base class for notifiers
+  class Base
+    class ParamsProxy
+      attr_reader :notifier_class, :params
+
+      def initialize(notifier_class, params)
+        @notifier_class = notifier_class
+        @params = params
+      end
+
+      # rubocop:disable Style/MethodMissingSuper
+      def method_missing(method_name, *args, **kwargs)
+        NotificationDelivery.new(notifier_class, method_name, params:, args:, kwargs:)
+      end
+      # rubocop:enable Style/MethodMissingSuper
+
+      def respond_to_missing?(*__rest__)
+        notifier_class.respond_to_missing?(*__rest__)
+      end
+    end
+
+    class << self
+      attr_writer :driver
+
+      def driver
+        return @driver if instance_variable_defined?(:@driver)
+
+        @driver =
+          if superclass.respond_to?(:driver)
+            superclass.driver
+          else
+            raise "Driver not found for #{name}. " \
+                  "Please, specify driver via `self.driver = MyDriver`"
+          end
+      end
+
+      def async_adapter=(args)
+        adapter, options = Array(args)
+        @async_adapter = AsyncAdapters.lookup(adapter, options)
+      end
+
+      def async_adapter
+        return @async_adapter if instance_variable_defined?(:@async_adapter)
+
+        @async_adapter =
+          if superclass.respond_to?(:async_adapter)
+            superclass.async_adapter
+          else
+            AbstractNotifier.async_adapter
+          end
+      end
+
+      def default(method_name = nil, **hargs, &block)
+        return @defaults_generator = block if block
+
+        return @defaults_generator = proc { send(method_name) } unless method_name.nil?
+
+        @default_params =
+          if superclass.respond_to?(:default_params)
+            superclass.default_params.merge(hargs).freeze
+          else
+            hargs.freeze
+          end
+      end
+
+      def defaults_generator
+        return @defaults_generator if instance_variable_defined?(:@defaults_generator)
+
+        @defaults_generator =
+          if superclass.respond_to?(:defaults_generator)
+            superclass.defaults_generator
+          end
+      end
+
+      def default_params
+        return @default_params if instance_variable_defined?(:@default_params)
+
+        @default_params =
+          if superclass.respond_to?(:default_params)
+            superclass.default_params.dup
+          else
+            {}
+          end
+      end
+
+      def method_missing(method_name, *args, **kwargs)
+        if action_methods.include?(method_name.to_s)
+          NotificationDelivery.new(self, method_name, args:, kwargs:)
+        else
+          super
+        end
+      end
+
+      def with(params)
+        ParamsProxy.new(self, params)
+      end
+
+      def respond_to_missing?(method_name, _include_private = false)
+        action_methods.include?(method_name.to_s) || super
+      end
+
+      # See https://github.com/rails/rails/blob/b13a5cb83ea00d6a3d71320fd276ca21049c2544/actionpack/lib/abstract_controller/base.rb#L74
+      def action_methods
+        @action_methods ||= begin
+          # All public instance methods of this class, including ancestors
+          methods = (public_instance_methods(true) -
+            # Except for public instance methods of Base and its ancestors
+            Base.public_instance_methods(true) +
+            # Be sure to include shadowed public instance methods of this class
+            public_instance_methods(false))
+
+          methods.map!(&:to_s)
+
+          methods.to_set
+        end
+      end
+    end
+
+    attr_reader :params, :notification_name
+
+    def initialize(notification_name, **params)
+      @notification_name = notification_name
+      @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 = 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
+          instance_exec(&self.class.defaults_generator)
+        else
+          self.class.default_params
+        end
+
+      defaults.each do |k, v|
+        payload[k] = v unless payload.key?(k)
+      end
+    end
+  end
+end