caffeinate 0.2.1 → 0.7.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
-
     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,17 +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
@@ -28,14 +24,4 @@ module Caffeinate
   def self.setup
     yield config
   end
-
-  # The current mailing
-  def self.current_mailing=(val)
-    Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY] = val
-  end
-
-  # The current mailing
-  def self.current_mailing
-    Thread.current[::Caffeinate::Mailing::CURRENT_THREAD_KEY]
-  end
 end

data/lib/caffeinate/action_mailer/extension.rb

@@ -7,7 +7,7 @@ module Caffeinate
     module Extension
       def self.included(klass)
         klass.before_action do
-          @mailing = Caffeinate.current_mailing if Caffeinate.current_mailing
+          @mailing = params[:mailing] if params
         end
 
         klass.helper_method :caffeinate_unsubscribe_url, :caffeinate_subscribe_url

data/lib/caffeinate/action_mailer/interceptor.rb

@@ -7,10 +7,10 @@ module Caffeinate
     class Interceptor
       # Handles `before_send` callbacks for a `Caffeinate::Dripper`
       def self.delivering_email(message)
-        mailing = Caffeinate.current_mailing
+        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 Caffeinate.current_mailing
+    # 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 = Caffeinate.current_mailing
+        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

@@ -5,30 +5,35 @@ module Caffeinate
     # Includes the ActiveRecord association and relevant scopes for an ActiveRecord-backed model
     module Extension
       # Adds the associations for a subscriber
-      def caffeinate_subscriber
+      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

@@ -3,19 +3,26 @@
 module Caffeinate
   # Global configuration
   class Configuration
-    attr_accessor :now, :async_delivery, :mailing_job, :batch_size
+    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,31 @@ 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?
+        date = start.from_now
+      else
+        date = options[:delay].from_now
+      end
+
+      if options[:at]
+        time = Time.parse(options[:at])
+        return date.change(hour: time.hour, min: time.min, sec: time.sec)
+      end
+
+      date
+    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

@@ -4,6 +4,7 @@ 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

@@ -8,6 +8,7 @@ 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
@@ -22,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

@@ -1,19 +1,21 @@
 # frozen_string_literal: true
 
 module Caffeinate
-  # 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
+  module Dripper
+    # Includes batch support for setting the batch size for Perform
+    module Batching
+      def self.included(klass)
+        klass.extend ClassMethods
       end
 
-      def _batch_size
-        @_batch_size || ::Caffeinate.config.batch_size
+      module ClassMethods
+        def batch_size=(num)
+          @batch_size = num
+        end
+
+        def batch_size
+          @batch_size || ::Caffeinate.config.batch_size
+        end
       end
     end
   end

data/lib/caffeinate/dripper/callbacks.rb

@@ -38,20 +38,36 @@ 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_process do |dripper|
+        #   before_perform do |dripper|
         #     Slack.notify(:caffeinate, "Dripper is getting ready for mailing! #{dripper.caffeinate_campaign.name}!")
         #   end
         #
         # @yield Caffeinate::Dripper
-        def before_process(&block)
-          before_process_blocks << block
+        def before_perform(&block)
+          before_perform_blocks << block
         end
 
         # :nodoc:
-        def before_process_blocks
-          @before_process_blocks ||= []
+        def before_perform_blocks
+          @before_perform_blocks ||= []
         end
 
         # Callback before the mailings get processed in a batch.
@@ -62,13 +78,13 @@ module Caffeinate
         #
         # @yield Caffeinate::Dripper
         # @yield Caffeinate::Mailing [Array]
-        def on_process(&block)
-          on_process_blocks << block
+        def on_perform(&block)
+          on_perform_blocks << block
         end
 
         # :nodoc:
-        def on_process_blocks
-          @on_process_blocks ||= []
+        def on_perform_blocks
+          @on_perform_blocks ||= []
         end
 
         # Callback after the all the mailings have been sent.
@@ -79,13 +95,13 @@ module Caffeinate
         #
         # @yield Caffeinate::Dripper
         # @yield Caffeinate::Mailing [Array]
-        def after_process(&block)
-          after_process_blocks << block
+        def after_perform(&block)
+          after_perform_blocks << block
         end
 
         # :nodoc:
-        def after_process_blocks
-          @after_process_blocks ||= []
+        def after_perform_blocks
+          @after_perform_blocks ||= []
         end
 
         # Callback before a Drip has called the mailer.
@@ -94,9 +110,8 @@ module Caffeinate
         #     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
@@ -112,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)
@@ -130,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)
@@ -174,13 +187,28 @@ 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`
         def on_skip(&block)
           on_skip_blocks << block