caffeinate 0.2.0 → 0.6.0

data/app/models/caffeinate/mailing.rb

@@ -17,12 +17,12 @@
 module Caffeinate
   # Records of the mails sent and to be sent for a given `::Caffeinate::CampaignSubscriber`
   class Mailing < ApplicationRecord
-    CURRENT_THREAD_KEY = :current_caffeinate_mailing.freeze
-
     self.table_name = 'caffeinate_mailings'
 
     belongs_to :caffeinate_campaign_subscription, class_name: 'Caffeinate::CampaignSubscription'
+    alias_attribute :subscription, :caffeinate_campaign_subscription
     has_one :caffeinate_campaign, through: :caffeinate_campaign_subscription
+    alias_attribute :campaign, :caffeinate_campaign
 
     scope :upcoming, -> { unsent.unskipped.where('send_at < ?', ::Caffeinate.config.time_now).order('send_at asc') }
     scope :unsent, -> { unskipped.where(sent_at: nil) }
@@ -30,6 +30,13 @@ module Caffeinate
     scope :skipped, -> { where.not(skipped_at: nil) }
     scope :unskipped, -> { where(skipped_at: nil) }
 
+    def initialize_dup(args)
+      super
+      self.send_at = nil
+      self.sent_at = nil
+      self.skipped_at = nil
+    end
+
     # Checks if the Mailing is not skipped and not sent
     def pending?
       unskipped? && unsent?
@@ -59,13 +66,12 @@ module Caffeinate
     def skip!
       update!(skipped_at: Caffeinate.config.time_now)
 
-      caffeinate_campaign.to_dripper.run_callbacks(:on_skip, caffeinate_campaign_subscription, self)
+      caffeinate_campaign.to_dripper.run_callbacks(:on_skip, self)
     end
 
     # The associated drip
-    # @todo This can be optimized with a better cache
     def drip
-      @drip ||= caffeinate_campaign.to_dripper.drip_collection[mailer_action]
+      @drip ||= caffeinate_campaign.to_dripper.drip_collection.for(mailer_action)
     end
 
     # The associated Subscriber from `::Caffeinate::CampaignSubscription`
@@ -80,7 +86,7 @@ module Caffeinate
 
     # Assigns attributes to the Mailing from the Drip
     def from_drip(drip)
-      self.send_at = drip.send_at
+      self.send_at = drip.send_at(self)
       self.mailer_class = drip.options[:mailer_class]
       self.mailer_action = drip.action
       self
@@ -93,6 +99,8 @@ module Caffeinate
       else
         deliver!
       end
+
+      caffeinate_campaign_subscription.touch
     end
 
     # Delivers the Mailing in the foreground

data/db/migrate/20201124183102_create_caffeinate_campaigns.rb

@@ -6,6 +6,7 @@ class CreateCaffeinateCampaigns < ActiveRecord::Migration[6.0]
     create_table :caffeinate_campaigns do |t|
       t.string :name, null: false
       t.string :slug, null: false
+      t.boolean :active, default: true, null: false
 
       t.timestamps
     end

data/db/migrate/20201124183303_create_caffeinate_campaign_subscriptions.rb

@@ -7,16 +7,19 @@ class CreateCaffeinateCampaignSubscriptions < ActiveRecord::Migration[6.0]
     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.integer :subscriber_id, null: false
       t.string :user_type
-      t.string :user_id
+      t.integer :user_id
       t.string :token, null: false
       t.datetime :ended_at
+      t.string :ended_reason
+      t.datetime :resubscribed_at
       t.datetime :unsubscribed_at
+      t.string :unsubscribe_reason
 
       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
+    add_index :caffeinate_campaign_subscriptions, %i[caffeinate_campaign_id subscriber_id subscriber_type user_id user_type ended_at resubscribed_at unsubscribed_at], name: :index_caffeinate_campaign_subscriptions
   end
 end

data/db/migrate/20201124183419_create_caffeinate_mailings.rb

@@ -14,6 +14,7 @@ class CreateCaffeinateMailings < ActiveRecord::Migration[6.0]
 
       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
+
+    add_index :caffeinate_mailings, %i[caffeinate_campaign_subscription_id send_at sent_at skipped_at], name: :index_caffeinate_mailings
   end
 end

data/lib/caffeinate.rb

@@ -1,22 +1,18 @@
 # frozen_string_literal: true
 
 require 'rails/all'
+require 'caffeinate/mail_ext'
 require 'caffeinate/engine'
 require 'caffeinate/drip'
 require 'caffeinate/url_helpers'
 require 'caffeinate/configuration'
 require 'caffeinate/dripper/base'
 require 'caffeinate/deliver_async'
+require 'caffeinate/dripper_collection'
 
 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
+  def self.dripper_collection
+    @drippers ||= DripperCollection.new
   end
 
   # Global configuration

data/lib/caffeinate/action_mailer.rb

@@ -1,6 +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'
+require 'mail'
+
+# Includes all files in `caffeinate/action_mailer`
+Dir["#{__dir__}/action_mailer/*"].each { |path| require "caffeinate/action_mailer/#{File.basename(path)}" }

data/lib/caffeinate/action_mailer/extension.rb

@@ -2,21 +2,27 @@
 
 module Caffeinate
   module ActionMailer
+    # Convenience for setting `@mailing`, and convenience methods for inferred `caffeinate_unsubscribe_url` and
+    # `caffeinate_subscribe_url`.
     module Extension
       def self.included(klass)
         klass.before_action do
-          @mailing = Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY] if Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY]
+          @mailing = params[:mailing] if params
         end
 
         klass.helper_method :caffeinate_unsubscribe_url, :caffeinate_subscribe_url
       end
 
-      def caffeinate_unsubscribe_url(**options)
-        Caffeinate::UrlHelpers.caffeinate_unsubscribe_url(@mailing.caffeinate_campaign_subscription, **options)
+      # Assumes `@mailing` is set
+      def caffeinate_unsubscribe_url(mailing: nil, **options)
+        mailing ||= @mailing
+        Caffeinate::UrlHelpers.caffeinate_unsubscribe_url(mailing.caffeinate_campaign_subscription, **options)
       end
 
-      def caffeinate_subscribe_url
-        Caffeinate::UrlHelpers.caffeinate_subscribe_url(@mailing.caffeinate_campaign_subscription, **options)
+      # Assumes `@mailing` is set
+      def caffeinate_subscribe_url(mailing: nil, **options)
+        mailing ||= @mailing
+        Caffeinate::UrlHelpers.caffeinate_subscribe_url(mailing.caffeinate_campaign_subscription, **options)
       end
     end
   end

data/lib/caffeinate/action_mailer/interceptor.rb

@@ -2,13 +2,15 @@
 
 module Caffeinate
   module ActionMailer
+    # Handles the evaluation of a drip against a mailing to determine if it ultimately gets delivered.
+    # Also invokes the `before_send` callbacks.
     class Interceptor
       # Handles `before_send` callbacks for a `Caffeinate::Dripper`
       def self.delivering_email(message)
-        mailing = Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY]
+        mailing = message.caffeinate_mailing
         return unless mailing
 
-        mailing.caffeinate_campaign.to_dripper.run_callbacks(:before_send, mailing.caffeinate_campaign_subscription, mailing, message)
+        mailing.caffeinate_campaign.to_dripper.run_callbacks(:before_send, mailing, message)
         drip = mailing.drip
         message.perform_deliveries = drip.enabled?(mailing)
       end

data/lib/caffeinate/action_mailer/observer.rb

@@ -2,15 +2,16 @@
 
 module Caffeinate
   module ActionMailer
-    # Handles updating the Caffeinate::Message if it's available in Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY]
+    # Handles updating the Caffeinate::Message if it's available in Mail::Message.caffeinate_mailing
     # and runs any associated callbacks
     class Observer
       def self.delivered_email(message)
-        mailing = Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY]
+        mailing = message.caffeinate_mailing
         return unless mailing
 
         mailing.update!(sent_at: Caffeinate.config.time_now, skipped_at: nil) if message.perform_deliveries
-        mailing.caffeinate_campaign.to_dripper.run_callbacks(:after_send, mailing.caffeinate_campaign_subscription, mailing, message)
+        mailing.caffeinate_campaign.to_dripper.run_callbacks(:after_send, mailing, message)
+        true
       end
     end
   end

data/lib/caffeinate/active_record/extension.rb

@@ -2,32 +2,38 @@
 
 module Caffeinate
   module ActiveRecord
+    # Includes the ActiveRecord association and relevant scopes for an ActiveRecord-backed model
     module Extension
       # Adds the associations for a subscriber
-      def caffeinate_subscriber
-        has_many :caffeinate_campaign_subscriptions, as: :subscriber, class_name: '::Caffeinate::CampaignSubscription'
+      def acts_as_caffeinate_subscriber
+        has_many :caffeinate_campaign_subscriptions, as: :subscriber, class_name: '::Caffeinate::CampaignSubscription', dependent: :destroy
         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_campaign, lambda { |list|
-          subscribed = ::Caffeinate::CampaignSubscription.select(:subscriber_id).joins(:caffeinate_campaign).where(caffeinate_campaigns: { slug: list }, subscriber_type: name)
-          where.not(id: subscribed)
+          where.not(id: ::Caffeinate::CampaignSubscription
+                            .select(:subscriber_id)
+                            .joins(:caffeinate_campaign)
+                            .where(subscriber_type: name, caffeinate_campaigns: { slug: list }))
         }
 
         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)
+          where(id: ::Caffeinate::CampaignSubscription
+                        .unsubscribed
+                        .select(:subscriber_id)
+                        .joins(:caffeinate_campaign)
+                        .where(subscriber_type: name, caffeinate_campaigns: { slug: list }))
         }
       end
+      alias caffeinate_subscriber acts_as_caffeinate_subscriber
 
       # Adds the associations for a user
-      def caffeinate_user
+      def acts_as_caffeinate_user
         has_many :caffeinate_campaign_subscriptions_as_user, as: :user, class_name: '::Caffeinate::CampaignSubscription'
+        has_many :caffeinate_campaigns_as_user, through: :caffeinate_campaign_subscriptions_as_user, class_name: '::Caffeinate::Campaign'
+        has_many :caffeinate_mailings_as_user, through: :caffeinate_campaign_subscriptions_as_user, class_name: '::Caffeinate::Campaign'
       end
+      alias caffeinate_user acts_as_caffeinate_user
     end
   end
 end

data/lib/caffeinate/configuration.rb

@@ -1,19 +1,28 @@
 # frozen_string_literal: true
 
 module Caffeinate
+  # Global configuration
   class Configuration
-    attr_accessor :now, :async_delivery, :mailing_job
+    attr_accessor :now, :async_delivery, :mailing_job, :batch_size, :drippers_path, :implicit_campaigns
 
     def initialize
       @now = -> { Time.current }
       @async_delivery = false
       @mailing_job = nil
+      @batch_size = 1_000
+      @drippers_path = 'app/drippers'
+      @implicit_campaigns = true
     end
 
     def now=(val)
       raise ArgumentError, '#now must be a proc' unless val.respond_to?(:call)
 
-      super
+      @now = val
+    end
+
+    # Automatically create a `::Caffeinate::Campaign` object if not found per `Dripper.inferred_campaign_slug`
+    def implicit_campaigns?
+      @implicit_campaigns == true
     end
 
     # The current time, for database calls

data/lib/caffeinate/drip.rb

@@ -7,6 +7,7 @@ module Caffeinate
   # Handles the block and provides convenience methods for the drip
   class Drip
     attr_reader :dripper, :action, :options, :block
+
     def initialize(dripper, action, options, &block)
       @dripper = dripper
       @action = action
@@ -19,12 +20,24 @@ module Caffeinate
       options[:using] == :parameterized
     end
 
-    def send_at
-      options[:delay].from_now
+    def send_at(mailing = nil)
+      if periodical?
+        start = mailing.instance_exec(&options[:start])
+        start += options[:every] if mailing.caffeinate_campaign_subscription.caffeinate_mailings.count.positive?
+        start.from_now
+      else
+        options[:delay].from_now
+      end
+    end
+
+    def periodical?
+      options[:every].present?
     end
 
     # Checks if the drip is enabled
     def enabled?(mailing)
+      dripper.run_callbacks(:before_drip, self, mailing)
+
       DripEvaluator.new(mailing).call(&@block)
     end
   end

data/lib/caffeinate/drip_evaluator.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Caffeinate
   # Handles evaluating the `drip` block and provides convenience methods for handling the mailing or its campaign.
   class DripEvaluator
     attr_reader :mailing
+
     def initialize(mailing)
       @mailing = mailing
     end

data/lib/caffeinate/dripper/base.rb

@@ -1,17 +1,21 @@
 # frozen_string_literal: true
 
-require 'caffeinate/dripper/drip'
-require 'caffeinate/dripper/inferences'
+require 'caffeinate/dripper/batching'
 require 'caffeinate/dripper/callbacks'
-require 'caffeinate/dripper/defaults'
-require 'caffeinate/dripper/subscriber'
 require 'caffeinate/dripper/campaign'
-require 'caffeinate/dripper/perform'
+require 'caffeinate/dripper/defaults'
 require 'caffeinate/dripper/delivery'
+require 'caffeinate/dripper/drip'
+require 'caffeinate/dripper/inferences'
+require 'caffeinate/dripper/perform'
+require 'caffeinate/dripper/periodical'
+require 'caffeinate/dripper/subscriber'
 
 module Caffeinate
   module Dripper
+    # Base class
     class Base
+      include Batching
       include Callbacks
       include Campaign
       include Defaults
@@ -19,7 +23,10 @@ module Caffeinate
       include Drip
       include Inferences
       include Perform
+      include Periodical
       include Subscriber
     end
   end
 end
+
+ActiveSupport.run_load_hooks :caffeinate, Caffeinate::Dripper::Base

data/lib/caffeinate/dripper/batching.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module Dripper
+    # Includes batch support for setting the batch size for Perform
+    module Batching
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def batch_size=(num)
+          @batch_size = num
+        end
+
+        def batch_size
+          @batch_size || ::Caffeinate.config.batch_size
+        end
+      end
+    end
+  end
+end

data/lib/caffeinate/dripper/callbacks.rb

@@ -2,12 +2,17 @@
 
 module Caffeinate
   module Dripper
+    # Callbacks for a Dripper.
     module Callbacks
       # :nodoc:
       def self.included(klass)
         klass.extend ClassMethods
       end
 
+      def run_callbacks(name, *args)
+        self.class.run_callbacks(name, *args)
+      end
+
       module ClassMethods
         # :nodoc:
         def run_callbacks(name, *args)
@@ -33,15 +38,80 @@ module Caffeinate
           @on_subscribe_blocks ||= []
         end
 
+        # Callback after a Caffeinate::CampaignSubscription is `#resubscribed!`
+        #
+        #   on_resubscribe do |campaign_subscription|
+        #     Slack.notify(:caffeinate, "Someone resubscribed to #{campaign_subscription.campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        def on_resubscribe(&block)
+          on_resubscribe_blocks << block
+        end
+
+        # :nodoc:
+        def on_resubscribe_blocks
+          @on_resubscribe_blocks ||= []
+        end
+
+        # Callback before the mailings get processed.
+        #
+        #   before_perform do |dripper|
+        #     Slack.notify(:caffeinate, "Dripper is getting ready for mailing! #{dripper.caffeinate_campaign.name}!")
+        #   end
+        #
+        # @yield Caffeinate::Dripper
+        def before_perform(&block)
+          before_perform_blocks << block
+        end
+
+        # :nodoc:
+        def before_perform_blocks
+          @before_perform_blocks ||= []
+        end
+
+        # Callback before the mailings get processed in a batch.
+        #
+        #   after_process do |dripper, mailings|
+        #     Slack.notify(:caffeinate, "Dripper #{dripper.name} sent #{mailings.size} mailings! Whoa!")
+        #   end
+        #
+        # @yield Caffeinate::Dripper
+        # @yield Caffeinate::Mailing [Array]
+        def on_perform(&block)
+          on_perform_blocks << block
+        end
+
+        # :nodoc:
+        def on_perform_blocks
+          @on_perform_blocks ||= []
+        end
+
+        # Callback after the all the mailings have been sent.
+        #
+        #   after_process do |dripper|
+        #     Slack.notify(:caffeinate, "Dripper #{dripper.name} sent #{mailings.size} mailings! Whoa!")
+        #   end
+        #
+        # @yield Caffeinate::Dripper
+        # @yield Caffeinate::Mailing [Array]
+        def after_perform(&block)
+          after_perform_blocks << block
+        end
+
+        # :nodoc:
+        def after_perform_blocks
+          @after_perform_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
+        # @yield Caffeinate::Mailing
         def before_drip(&block)
           before_drip_blocks << block
         end
@@ -57,7 +127,6 @@ module Caffeinate
         #     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)
@@ -75,7 +144,6 @@ module Caffeinate
         #     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)
@@ -119,14 +187,29 @@ module Caffeinate
           @on_unsubscribe_blocks ||= []
         end
 
+        # Callback after a CampaignSubscriber has ended.
+        #
+        #   on_end do |campaign_sub|
+        #     Slack.notify(:caffeinate, "#{campaign_sub.id} has ended... sad day.")
+        #   end
+        #
+        # @yield Caffeinate::CampaignSubscription
+        def on_end(&block)
+          on_end_blocks << block
+        end
+
+        # :nodoc:
+        def on_end_blocks
+          @on_end_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
+        # @yield `Caffeinate::Mailing`
         def on_skip(&block)
           on_skip_blocks << block
         end