active_delivery 0.4.3 → 1.0.0.rc2

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  # Base class for deliveries.
+  #
+  # Delivery object describes how to notify a user about
+  # an event (e.g. via email or via push notification or both).
+  #
+  # Delivery class acts like a proxy in front of the different delivery channels
+  # (i.e. mailers, notifiers). That means that calling a method on delivery class invokes the
+  # same method on the corresponding class, e.g.:
+  #
+  #   EventsDelivery.notify(:one_hour_before, profile, event)
+  #
+  #   # under the hood it calls
+  #   EventsMailer.one_hour_before(profile, event).deliver_later
+  #
+  #   # and
+  #   EventsNotifier.one_hour_before(profile, event).notify_later
+  #
+  # Delivery also supports _parameterized_ calling:
+  #
+  #   EventsDelivery.with(profile: profile).notify(:canceled, event)
+  #
+  # 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)
+  #
+  # See https://api.rubyonrails.org/classes/ActionMailer/Parameterized.html
+  class Base
+    class << self
+      attr_accessor :abstract_class
+
+      alias_method :with, :new
+
+      # Enqueues delivery (i.e. uses #deliver_later for mailers)
+      def notify(...)
+        new.notify(...)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify)
+
+      # The same as .notify but delivers synchronously
+      # (i.e. #deliver_now for mailers)
+      def notify!(mid, *args, **hargs)
+        notify(mid, *args, **hargs, sync: true)
+      end
+
+      def delivery_lines
+        @lines ||= if superclass.respond_to?(:delivery_lines)
+          superclass.delivery_lines.each_with_object({}) do |(key, val), acc|
+            acc[key] = val.dup_for(self)
+          end
+        else
+          {}
+        end
+      end
+
+      def register_line(line_id, line_class, **options)
+        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
+          end
+
+          def #{line_id}_class
+            delivery_lines[:#{line_id}].handler_class
+          end
+        CODE
+      end
+
+      def unregister_line(line_id)
+        removed_line = delivery_lines.delete(line_id)
+
+        return if removed_line.nil?
+
+        singleton_class.undef_method line_id
+        singleton_class.undef_method "#{line_id}_class"
+      end
+
+      def abstract_class? ;  abstract_class == true; end
+    end
+
+    attr_reader :params, :notification_name
+
+    def initialize(**params)
+      @params = params
+      @params.freeze
+    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)
+
+    # The same as .notify but delivers synchronously
+    # (i.e. #deliver_now for mailers)
+    def notify!(mid, *args, **hargs)
+      notify(mid, *args, **hargs, sync: true)
+    end
+
+    private
+
+    def do_notify(*args, sync: false, **kwargs)
+      delivery_lines.each do |type, line|
+        next if line.handler_class.nil?
+        next unless line.notify?(notification_name)
+
+        notify_line(type, *args, params: params, sync: sync, **kwargs)
+      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)
+
+    def delivery_lines
+      self.class.delivery_lines
+    end
+  end
+end

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

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "active_support/version"
+require "active_support/callbacks"
+require "active_support/concern"
+
+module ActiveDelivery
+  # Add callbacks support to Active Delivery (requires ActiveSupport::Callbacks)
+  #
+  #   # Run method before delivering notification
+  #   # NOTE: when `false` is returned the execution is halted
+  #   before_notify :do_something
+  #
+  #   # You can specify a notification method (to run callback only for that method)
+  #   before_notify :do_mail_something, on: :mail
+  #
+  #   # or for push notifications
+  #   before_notify :do_mail_something, on: :push
+  #
+  #   # after_ and around_ callbacks are also supported
+  #   after_notify :cleanup
+  #
+  #   around_notify :set_context
+  module Callbacks
+    extend ActiveSupport::Concern
+
+    include ActiveSupport::Callbacks
+
+    CALLBACK_TERMINATOR = ->(_target, result) { result.call == false }
+
+    included do
+      # Define "global" callbacks
+      define_line_callbacks :notify
+
+      prepend InstanceExt
+      singleton_class.prepend SingltonExt
+    end
+
+    module InstanceExt
+      def do_notify(...)
+        run_callbacks(:notify) { super(...) }
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :do_notify)
+
+      def notify_line(kind, *__rest__, &__block__)
+        run_callbacks(kind) { super(kind, *__rest__, &__block__) }
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_line)
+    end
+
+    module SingltonExt
+      def register_line(line_id, *__rest__, &__block__)
+        super
+        define_line_callbacks line_id
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :register_line)
+    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
+
+      def define_line_callbacks(name)
+        define_callbacks name,
+          terminator: CALLBACK_TERMINATOR,
+          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
+
+      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
+
+      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
+      end
+    end
+  end
+end
+
+ActiveDelivery::Base.include ActiveDelivery::Callbacks

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module Lines
+    class Base
+      attr_reader :id, :options
+      attr_accessor :owner
+      attr_writer :handler_class
+
+      def initialize(id:, owner:, **options)
+        @id = id
+        @owner = owner
+        @options = options.tap(&:freeze)
+        @resolver = options[:resolver]
+      end
+
+      def dup_for(new_owner)
+        self.class.new(id: id, **options, owner: new_owner)
+      end
+
+      def resolve_class(name)
+        resolver&.call(name)
+      end
+
+      def notify?(method_name)
+        handler_class.respond_to?(method_name)
+      end
+
+      def notify_now(handler, mid, *__rest__, &__block__)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_now)
+
+      def notify_later(handler, mid, *__rest__, &__block__)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_later)
+
+      def notify(mid, *args, params:, sync:, **kwargs)
+        clazz = params.empty? ? handler_class : handler_class.with(**params)
+        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+      end
+
+      def handler_class
+        return @handler_class if instance_variable_defined?(:@handler_class)
+
+        return @handler_class = nil if owner.abstract_class?
+
+        @handler_class = resolve_class(owner.name) ||
+          superclass_handler
+      end
+
+      private
+
+      def superclass_handler
+        handler_method = "#{id}_class"
+
+        return if owner.superclass == ActiveDelivery::Base
+        return unless owner.superclass.respond_to?(handler_method)
+
+        owner.superclass.public_send(handler_method)
+      end
+
+      attr_reader :resolver
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module Lines
+    class Mailer < Base
+      alias_method :mailer_class, :handler_class
+
+      DEFAULT_RESOLVER = ->(name) { name.gsub(/Delivery$/, "Mailer").safe_constantize }
+
+      def notify?(method_name)
+        mailer_class.action_methods.include?(method_name.to_s)
+      end
+
+      def notify_now(mailer, mid, *__rest__, &__block__)
+        mailer.public_send(mid, *__rest__, &__block__).deliver_now
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :notify_now)
+
+      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)
+    end
+
+    ActiveDelivery::Base.register_line :mailer, Mailer, resolver: Mailer::DEFAULT_RESOLVER
+  end
+end

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

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  # Base class for deliveries.
+  #
+  # Delivery object describes how to notify a user about
+  # an event (e.g. via email or via push notification or both).
+  #
+  # Delivery class acts like a proxy in front of the different delivery channels
+  # (i.e. mailers, notifiers). That means that calling a method on delivery class invokes the
+  # same method on the corresponding class, e.g.:
+  #
+  #   EventsDelivery.notify(:one_hour_before, profile, event)
+  #
+  #   # under the hood it calls
+  #   EventsMailer.one_hour_before(profile, event).deliver_later
+  #
+  #   # and
+  #   EventsNotifier.one_hour_before(profile, event).notify_later
+  #
+  # Delivery also supports _parameterized_ calling:
+  #
+  #   EventsDelivery.with(profile: profile).notify(:canceled, event)
+  #
+  # 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)
+  #
+  # See https://api.rubyonrails.org/classes/ActionMailer/Parameterized.html
+  class Base
+    class << self
+      attr_accessor :abstract_class
+
+      alias_method :with, :new
+
+      # Enqueues delivery (i.e. uses #deliver_later for mailers)
+      def notify(...)
+        new.notify(...)
+      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)
+      end
+
+      def delivery_lines
+        @lines ||= if superclass.respond_to?(:delivery_lines)
+          superclass.delivery_lines.each_with_object({}) do |(key, val), acc|
+            acc[key] = val.dup_for(self)
+          end
+        else
+          {}
+        end
+      end
+
+      def register_line(line_id, line_class, **options)
+        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
+          end
+
+          def #{line_id}_class
+            delivery_lines[:#{line_id}].handler_class
+          end
+        CODE
+      end
+
+      def unregister_line(line_id)
+        removed_line = delivery_lines.delete(line_id)
+
+        return if removed_line.nil?
+
+        singleton_class.undef_method line_id
+        singleton_class.undef_method "#{line_id}_class"
+      end
+
+      def abstract_class? = abstract_class == true
+    end
+
+    attr_reader :params, :notification_name
+
+    def initialize(**params)
+      @params = params
+      @params.freeze
+    end
+
+    # Enqueues delivery (i.e. uses #deliver_later for mailers)
+    def notify(mid, ...)
+      @notification_name = mid
+      do_notify(...)
+    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)
+    end
+
+    private
+
+    def do_notify(*args, sync: false, **kwargs)
+      delivery_lines.each do |type, line|
+        next if line.handler_class.nil?
+        next unless line.notify?(notification_name)
+
+        notify_line(type, *args, params: params, sync: sync, **kwargs)
+      end
+    end
+
+    def notify_line(type, ...)
+      delivery_lines[type].notify(notification_name, ...)
+    end
+
+    def delivery_lines
+      self.class.delivery_lines
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module Lines
+    class Base
+      attr_reader :id, :options
+      attr_accessor :owner
+      attr_writer :handler_class
+
+      def initialize(id:, owner:, **options)
+        @id = id
+        @owner = owner
+        @options = options.tap(&:freeze)
+        @resolver = options[:resolver]
+      end
+
+      def dup_for(new_owner)
+        self.class.new(id: id, **options, owner: new_owner)
+      end
+
+      def resolve_class(name)
+        resolver&.call(name)
+      end
+
+      def notify?(method_name)
+        handler_class.respond_to?(method_name)
+      end
+
+      def notify_now(handler, mid, ...)
+      end
+
+      def notify_later(handler, mid, ...)
+      end
+
+      def notify(mid, *args, params:, sync:, **kwargs)
+        clazz = params.empty? ? handler_class : handler_class.with(**params)
+        sync ? notify_now(clazz, mid, *args, **kwargs) : notify_later(clazz, mid, *args, **kwargs)
+      end
+
+      def handler_class
+        return @handler_class if instance_variable_defined?(:@handler_class)
+
+        return @handler_class = nil if owner.abstract_class?
+
+        @handler_class = resolve_class(owner.name) ||
+          superclass_handler
+      end
+
+      private
+
+      def superclass_handler
+        handler_method = "#{id}_class"
+
+        return if owner.superclass == ActiveDelivery::Base
+        return unless owner.superclass.respond_to?(handler_method)
+
+        owner.superclass.public_send(handler_method)
+      end
+
+      attr_reader :resolver
+    end
+  end
+end

data/lib/abstract_notifier/async_adapters/active_job.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  module AsyncAdapters
+    class ActiveJob
+      class DeliveryJob < ::ActiveJob::Base
+        def perform(notifier_class, payload)
+          AbstractNotifier::Notification.new(notifier_class.constantize, payload).notify_now
+        end
+      end
+
+      DEFAULT_QUEUE = "notifiers"
+
+      attr_reader :job
+
+      def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
+        @job = job.set(queue: queue)
+      end
+
+      def enqueue(notifier_class, payload)
+        job.perform_later(notifier_class.name, payload)
+      end
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job

data/lib/abstract_notifier/async_adapters.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AbstractNotifier
+  module AsyncAdapters
+    class << self
+      def lookup(adapter, options = nil)
+        return adapter unless adapter.is_a?(Symbol)
+
+        adapter_class_name = adapter.to_s.split("_").map(&:capitalize).join
+        AsyncAdapters.const_get(adapter_class_name).new(**(options || {}))
+      rescue NameError => e
+        raise e.class, "Notifier async adapter :#{adapter} haven't been found", e.backtrace
+      end
+    end
+  end
+end