caffeinate 0.1.0

data/db/migrate/20201124183102_create_caffeinate_campaigns.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CreateCaffeinateCampaigns < ActiveRecord::Migration[6.0]
+  def change
+    drop_table :caffeinate_campaigns if table_exists?(:caffeinate_campaigns)
+    create_table :caffeinate_campaigns do |t|
+      t.string :name, null: false
+      t.string :slug, null: false
+
+      t.timestamps
+    end
+    add_index :caffeinate_campaigns, :slug, unique: true
+  end
+end

data/db/migrate/20201124183303_create_caffeinate_campaign_subscriptions.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class CreateCaffeinateCampaignSubscriptions < ActiveRecord::Migration[6.0]
+  def change
+    drop_table :caffeinate_campaign_subscriptions if table_exists?(:caffeinate_campaign_subscriptions)
+
+    create_table :caffeinate_campaign_subscriptions do |t|
+      t.references :caffeinate_campaign, null: false, index: { name: :caffeineate_campaign_subscriptions_on_campaign }, foreign_key: true
+      t.string :subscriber_type, null: false
+      t.string :subscriber_id, null: false
+      t.string :user_type
+      t.string :user_id
+      t.string :token, null: false
+      t.datetime :ended_at
+      t.datetime :unsubscribed_at
+
+      t.timestamps
+    end
+    add_index :caffeinate_campaign_subscriptions, :token, unique: true
+    add_index :caffeinate_campaign_subscriptions, %i[subscriber_id subscriber_type user_id user_type], name: :index_caffeinate_campaign_subscriptions
+  end
+end

data/db/migrate/20201124183419_create_caffeinate_mailings.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class CreateCaffeinateMailings < ActiveRecord::Migration[6.0]
+  def change
+    drop_table :caffeinate_mailings if table_exists?(:caffeinate_mailings)
+
+    create_table :caffeinate_mailings do |t|
+      t.references :caffeinate_campaign_subscription, null: false, foreign_key: true, index: { name: 'index_caffeinate_mailings_on_campaign_subscription' }
+      t.datetime :send_at
+      t.datetime :sent_at
+      t.datetime :skipped_at
+      t.string :mailer_class, null: false
+      t.string :mailer_action, null: false
+
+      t.timestamps
+    end
+    add_index :caffeinate_mailings, %i[campaign_subscription_id mailer_class mailer_action sent_at send_at skipped_at], name: :index_caffeinate_mailings
+  end
+end

data/lib/caffeinate.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'rails/all'
+require 'caffeinate/engine'
+require 'caffeinate/drip'
+require 'caffeinate/configuration'
+require 'caffeinate/dripper/base'
+require 'caffeinate/deliver_async'
+
+module Caffeinate
+  # Caches the campaign to the campaign class
+  def self.dripper_to_campaign_class
+    @dripper_to_campaign_class ||= {}
+  end
+
+  # Convenience method for `dripper_to_campaign_class`
+  def self.register_dripper(name, klass)
+    dripper_to_campaign_class[name.to_sym] = klass
+  end
+
+  # Global configuration
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  # Yields the configuration
+  def self.setup
+    yield config
+  end
+end

data/lib/caffeinate/action_mailer.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require 'caffeinate/action_mailer/extension'
+require 'caffeinate/action_mailer/helpers'
+require 'caffeinate/action_mailer/interceptor'
+require 'caffeinate/action_mailer/observer'

data/lib/caffeinate/action_mailer/extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module ActionMailer
+    module Extension
+      def self.included(klass)
+        klass.before_action do
+          @mailing = Thread.current[:current_caffeinate_mailing] if Thread.current[:current_caffeinate_mailing]
+        end
+      end
+    end
+  end
+end

data/lib/caffeinate/action_mailer/helpers.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module ActionMailer
+    module Helpers
+      def caffeinate_unsubscribe_url(caffeinate_campaign_subscription, **options)
+        opts = (::ActionMailer::Base.default_url_options || {}).merge(options)
+        Caffeinate::Engine.routes.url_helpers.caffeinate_unsubscribe_url(token: caffeinate_campaign_subscription.token, **opts)
+      end
+    end
+  end
+end

data/lib/caffeinate/action_mailer/interceptor.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module ActionMailer
+    class Interceptor
+      # Handles `before_send` callbacks for a `Caffeinate::Dripper`
+      def self.delivering_email(message)
+        mailing = Thread.current[:current_caffeinate_mailing]
+        return unless mailing
+
+        mailing.caffeinate_campaign.to_dripper.run_callbacks(:before_send, mailing.caffeinate_campaign_subscription, mailing, message)
+        drip = mailing.drip
+        message.perform_deliveries = drip.enabled?(mailing)
+      end
+    end
+  end
+end

data/lib/caffeinate/action_mailer/observer.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module ActionMailer
+    # Handles updating the Caffeinate::Message if it's available in Thread.current[:current_caffeinate_mailing]
+    # and runs any associated callbacks
+    class Observer
+      def self.delivered_email(message)
+        mailing = Thread.current[:current_caffeinate_mailing]
+        return unless mailing
+
+        mailing.update!(sent_at: Caffeinate.config.time_now) if message.perform_deliveries
+        mailing.caffeinate_campaign.to_dripper.run_callbacks(:after_send, mailing.caffeinate_campaign_subscription, mailing, message)
+      end
+    end
+  end
+end

data/lib/caffeinate/active_record/extension.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module ActiveRecord
+    module Extension
+      # Adds the associations for a subscriber
+      def caffeinate_subscriber
+        has_many :caffeinate_campaign_subscriptions, as: :subscriber, class_name: '::Caffeinate::CampaignSubscription'
+        has_many :caffeinate_campaigns, through: :caffeinate_campaign_subscriptions, class_name: '::Caffeinate::Campaign'
+        has_many :caffeinate_mailings, through: :caffeinate_campaign_subscriptions, class_name: '::Caffeinate::Mailing'
+
+        scope :not_subscribed_to, lambda { |list|
+          subscribed = ::Caffeinate::CampaignSubscription.select(:subscriber_id).joins(:caffeinate_campaign).where(caffeinate_campaigns: { slug: list }, subscriber_type: name)
+          where.not(id: subscribed)
+        }
+
+        scope :unsubscribed_from_campaign, lambda { |list|
+          unsubscribed = ::Caffeinate::CampaignSubscription
+                         .unsubscribed
+                         .select(:subscriber_id)
+                         .joins(:caffeinate_campaign)
+                         .where(caffeinate_campaigns: { slug: list }, subscriber_type: name)
+          where(id: unsubscribed)
+        }
+      end
+
+      # Adds the associations for a user
+      def caffeinate_user
+        has_many :caffeinate_campaign_subscriptions_as_user, as: :user, class_name: '::Caffeinate::CampaignSubscription'
+      end
+    end
+  end
+end

data/lib/caffeinate/configuration.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  class Configuration
+    attr_accessor :now, :async_delivery, :mailing_job
+
+    def initialize
+      @now = -> { Time.current }
+      @async_delivery = false
+      @mailing_job = nil
+    end
+
+    def now=(val)
+      raise ArgumentError, '#now must be a proc' unless val.respond_to?(:call)
+
+      super
+    end
+
+    # The current time, for database calls
+    def time_now
+      @now.call
+    end
+
+    # If delivery is asyncronous
+    def async_delivery?
+      @async_delivery
+    end
+
+    # The @mailing_job constantized. Only used if `async_delivery = true`
+    def mailing_job_class
+      @mailing_job.constantize
+    end
+  end
+end

data/lib/caffeinate/deliver_async.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # Method for handling async delivery. `include` it for plug-and-play.
+  #
+  #   class MyWorker
+  #     include Sidekiq::Worker
+  #     include Caffeinate::AsyncMailing
+  #   end
+  #
+  # To use this, make sure your initializer is configured correctly:
+  #   config.async_delivery = true
+  #   config.mailing_job = 'MyWorker'
+  module DeliverAsync
+    def perform(mailing_id)
+      mailing = ::Caffeinate::Mailing.find(mailing_id)
+      return unless mailing.pending?
+
+      mailing.deliver!
+    end
+  end
+end

data/lib/caffeinate/drip.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # A Drip object
+  class Drip
+    # Handles the block and provides convenience methods for the drip
+    class Evaluator
+      attr_reader :mailing
+      def initialize(mailing)
+        @mailing = mailing
+      end
+
+      def call(&block)
+        return true unless block
+
+        instance_eval(&block)
+      end
+
+      # Ends the CampaignSubscription
+      def end!
+        mailing.caffeinate_campaign_subscription.end!
+        false
+      end
+
+      # Unsubscribes the CampaignSubscription
+      def unsubscribe!
+        mailing.caffeinate_campaign_subscription.unsubscribe!
+        false
+      end
+
+      # Skips the mailing
+      def skip!
+        mailing.skip!
+        false
+      end
+    end
+
+    attr_reader :dripper, :action, :options, :block
+    def initialize(dripper, action, options, &block)
+      @dripper = dripper
+      @action = action
+      @options = options
+      @block = block
+    end
+
+    # If the associated ActionMailer uses `ActionMailer::Parameterized` initialization
+    def parameterized?
+      options[:using] == :parameterized
+    end
+
+    # If the drip is enabled.
+    def enabled?(mailing)
+      Evaluator.new(mailing).call(&@block)
+    end
+  end
+end

data/lib/caffeinate/dripper/base.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'caffeinate/dripper/drip'
+require 'caffeinate/dripper/callbacks'
+require 'caffeinate/dripper/defaults'
+require 'caffeinate/dripper/subscriber'
+require 'caffeinate/dripper/campaign'
+require 'caffeinate/dripper/perform'
+require 'caffeinate/dripper/delivery'
+
+module Caffeinate
+  module Dripper
+    class Base
+      include Callbacks
+      include Campaign
+      include Defaults
+      include Delivery
+      include Drip
+      include Perform
+      include Subscriber
+
+      # The inferred mailer class
+      def self.inferred_mailer_class
+        klass_name = "#{name.delete_suffix('Dripper')}Mailer"
+        klass = klass_name.safe_constantize
+        return nil unless klass
+        return klass_name if klass < ::ActionMailer::Base
+
+        nil
+      end
+    end
+  end
+end

data/lib/caffeinate/dripper/callbacks.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module Dripper
+    module Callbacks
+      # :nodoc:
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # :nodoc:
+        def run_callbacks(name, *args)
+          send("#{name}_blocks").each do |callback|
+            callback.call(*args)
+          end
+        end
+
+        # Callback after a Caffeinate::CampaignSubscription is created, and after the Caffeinate::Mailings have
+        # been created.
+        #
+        #   on_subscribe do |campaign_subscription|
+        #     Slack.notify(:caffeinate, "A new subscriber to #{campaign_subscription.campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        def on_subscribe(&block)
+          on_subscribe_blocks << block
+        end
+
+        # :nodoc:
+        def on_subscribe_blocks
+          @on_subscribe_blocks ||= []
+        end
+
+        # Callback before a Drip has called the mailer.
+        #
+        #   before_drip do |campaign_subscription, mailing, drip|
+        #     Slack.notify(:caffeinate, "#{drip.action_name} is starting")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        # @yield Caffeinate::Mailing
+        # @yield Caffeinate::Drip current drip
+        def before_drip(&block)
+          before_drip_blocks << block
+        end
+
+        # :nodoc:
+        def before_drip_blocks
+          @before_drip_blocks ||= []
+        end
+
+        # Callback before a Mailing has been sent.
+        #
+        #   before_send do |campaign_subscription, mailing, message|
+        #     Slack.notify(:caffeinate, "A new subscriber to #{campaign_subscription.campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        # @yield Caffeinate::Mailing
+        # @yield Mail::Message
+        def before_send(&block)
+          before_send_blocks << block
+        end
+
+        # :nodoc:
+        def before_send_blocks
+          @before_send_blocks ||= []
+        end
+
+        # Callback after a Mailing has been sent.
+        #
+        #   after_send do |campaign_subscription, mailing, message|
+        #     Slack.notify(:caffeinate, "A new subscriber to #{campaign_subscription.campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        # @yield Caffeinate::Mailing
+        # @yield Mail::Message
+        def after_send(&block)
+          after_send_blocks << block
+        end
+
+        # :nodoc:
+        def after_send_blocks
+          @after_send_blocks ||= []
+        end
+
+        # Callback after a CampaignSubscriber has exhausted all their mailings.
+        #
+        #   on_complete do |campaign_sub|
+        #     Slack.notify(:caffeinate, "A subscriber completed #{campaign_sub.campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        def on_complete(&block)
+          on_complete_blocks << block
+        end
+
+        # :nodoc:
+        def on_complete_blocks
+          @on_complete_blocks ||= []
+        end
+
+        # Callback after a CampaignSubscriber has unsubscribed.
+        #
+        #   on_unsubscribe do |campaign_sub|
+        #     Slack.notify(:caffeinate, "#{campaign_sub.id} has unsubscribed... sad day.")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        def on_unsubscribe(&block)
+          on_unsubscribe_blocks << block
+        end
+
+        # :nodoc:
+        def on_unsubscribe_blocks
+          @on_unsubscribe_blocks ||= []
+        end
+
+        # Callback after a `Caffeinate::Mailing` is skipped.
+        #
+        #   on_skip do |campaign_subscription, mailing, message|
+        #     Slack.notify(:caffeinate, "#{campaign_sub.id} has unsubscribed... sad day.")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        # @yield Caffeinate::Mailing
+        def on_skip(&block)
+          on_skip_blocks << block
+        end
+
+        # :nodoc:
+        def on_skip_blocks
+          @on_skip_blocks ||= []
+        end
+      end
+    end
+  end
+end