active_delivery 0.4.4 → 1.0.0

data/lib/.rbnext/3.0/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, *__rest__, &__block__)
+          AbstractNotifier::NotificationDelivery.new(notifier_class.constantize, *__rest__, &__block__).notify_now
+        end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :perform)
+      end
+
+      DEFAULT_QUEUE = "notifiers"
+
+      attr_reader :job
+
+      def initialize(queue: DEFAULT_QUEUE, job: DeliveryJob)
+        @job = job.set(queue: queue)
+      end
+
+      def enqueue(...)
+        job.perform_later(...)
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :enqueue)
+    end
+  end
+end
+
+AbstractNotifier.async_adapter ||= :active_job

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

@@ -0,0 +1,248 @@
+# 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 ;  owner.perform_notify(self); end
+
+    def deliver_now ;  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
+  # 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.one_hour_before(profile, event).deliver_later
+  #   # or
+  #   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).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).deliver_later
+  #
+  # 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
+
+      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|
+            acc[key] = val.dup_for(self)
+          end
+        else
+          {}
+        end
+      end
+
+      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_name = 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
+
+      # 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)
+      @params = params
+      @params.freeze
+    end
+
+    # Enqueues delivery (i.e. uses #deliver_later for mailers)
+    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, **kwargs)
+      perform_notify(
+        delivery(notification: mid, params: args, options: kwargs),
+        sync: true
+      )
+    end
+
+    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 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)
+      delivery_lines.each do |type, line|
+        next unless line.notify?(delivery.notification)
+
+        notify_line(type, line, delivery, sync: sync)
+      end
+    end
+
+    private
+
+    def notify_line(type, line, delivery, sync:)
+      line.notify(
+        delivery.notification,
+        *delivery.params,
+        params: params,
+        sync: sync,
+        **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
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# 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 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__) }
+      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
+
+      %i[before after around].each do |kind|
+        define_method "#{kind}_notify" do |*names, on: :notify, **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}_notify" do |*names, on: :notify, **options|
+          _normalize_callback_options(options)
+
+          names.each do |name|
+            skip_callback(on, kind, name, options)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveDelivery::Base.include ActiveDelivery::Callbacks

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

@@ -0,0 +1,89 @@
+# 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_accessor :handler_class_name
+
+      def initialize(id:, owner:, **options)
+        @id = id
+        @owner = owner
+        @options = options.tap(&:freeze)
+        @resolver = options[:resolver] || build_pattern_resolver(options[:resolver_pattern])
+      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
+        if ::ActiveDelivery.cache_classes
+          return @handler_class if instance_variable_defined?(:@handler_class)
+        end
+
+        return @handler_class = nil if owner.abstract_class?
+
+        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
+
+      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_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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveDelivery
+  module Lines
+    class Mailer < Base
+      alias_method :mailer_class, :handler_class
+
+      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
+
+      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.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)