caffeinate 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8395725b8aadbadd9e4531ca57c45b1f2d5cb1655568d0dc293e75fd9d96d027
-  data.tar.gz: c630d7fa84abfd1ad3d402a7e299696ad9ebe783d8e9a975f35680026a7ca3f3
+  metadata.gz: 3241ca7ca0c6e31220511ad04172105d97058fa84f1de1e6ac442052823a91e0
+  data.tar.gz: 5b0bda6f08ae89f79cbd64df4c75f48fcb0dacf7471155aae779290b6a1b2e41
 SHA512:
-  metadata.gz: 9b507434acc98924a29e541de7d0cd239ae72e6462b620f76c829b640644a0bf6bf8ccff46a0fbecfe788e934db11d313384169d77576ef1fd32ddbc7082c8cd
-  data.tar.gz: 6ec96833ba77d9ff66c0114d6911f8d5e17eed36c0c596541fdc3055b5c211f95f7983c3a56a183fc5090baefe4f2c5a31f5b87926a7b0cc8989d007f4df6e79
+  metadata.gz: d43a0030851c7fa107fed83fcc05c9cfa8596be068a8327d01f597a0a45fc84aa403d1a95990e8a4c45013fb44bc899215778d36ce8a8f5cc770db50b33cd0df
+  data.tar.gz: 6f9e399cc7e0a00bbb544b668d80e0438f4482013f3163a819b9f2ab8ea502f3c8535aacb91d57eb80efc5f12c22bd03a2bdfd36c2216544bb9aa1fd6928e797

data/README.md

@@ -1,81 +1,89 @@
 # Caffeinate
 
-Ruby on Rails drip campaign engine. 
+Caffeinate is a drip campaign engine for Ruby on Rails applications.
 
-## Are there docs?
-
-[Since you asked](https://rubydoc.info/github/joshmn/caffeinate).
+Caffeinate tries to make creating and managing timed and scheduled email sequences fun. It works alongside ActionMailer 
+and has everything you need to get started and to successfully manage campaigns. It's only dependency is the stack you're
+already familiar with: Ruby on Rails.
 
 ## Usage
 
-Given a mailer like this:
+You can probably imagine seeing a Mailer like this:
 
 ```ruby 
-class AbandonedCartMailer < ActionMailer::Base 
-  def you_forgot_something(cart)
-    mail(to: cart.user.email, subject: "You forgot something!")
+class OnboardingMailer < ActionMailer::Base 
+  # Send on account creation
+  def welcome_to_my_cool_app(user)
+    mail(to: user.email, subject: "You forgot something!")
   end
 
-  def selling_out_soon(cart)
-    mail(to: cart.user.email, subject: "Selling out soon!")
+  # Send 2 days after the user signs up
+  def some_cool_tips(user)
+    mail(to: user.email, subject: "Here are some cool tips for MyCoolApp")
+  end 
+
+  # Sends 3 days after the user signs up and hasn't added a company profile yet
+  def help_getting_started(user)
+    return if user.company.present?
+
+    mail(to: user.email, subject: "Did you know...")
   end 
 end 
 ```
 
+With background jobs running, checking, and everything else. That's messy. Why are we checking state in the Mailer? Ugh.
+
+We can clean this up with Caffeinate. Here's how we'd do it.
+
 ### Create a Campaign
 
 ```ruby 
-Caffeinate::Campaign.create!(name: "Abandoned Cart", slug: "abandoned_cart") 
+Caffeinate::Campaign.create!(name: "Onboarding Campaign", slug: "onboarding") 
 ```
 
 ### Create a Caffeinate::Dripper
 
+Place the contents below in `app/drippers/onboarding_dripper.rb`:
+
 ```ruby 
-class AbandonedCartDripper < Caffeinate::Dripper::Base
-  # This should match a Caffeinate::Campaign#slug
-  campaign :abandoned_cart 
-  
-  # A block to subscribe your users automatically 
-  # You can invoke this by calling `AbandonedCartDripper.subscribe!`,
-  # probably in a background process, run at a given interval 
-  subscribes do 
-    Cart.left_joins(:cart_items)
-        .includes(:user)
-        .where(completed_at: nil)
-        .where(updated_at: 1.day.ago..2.days.ago)
-        .having('count(cart_items.id) = 0').each do |cart|
-      subscribe(cart, user: cart.user)
-    end 
-  end 
-  
-  # Register your drips! Syntax is
-  # drip <mailer_action_name>, mailer: <MailerClass>, delay: <ActiveSupport::Interval>
-  drip :you_forgot_something, mailer: "AbandonedCartMailer", delay: 1.hour 
-  drip :selling_out_soon, mailer: "AbandonedCartMailer", delay: 8.hours do 
-    cart = mailing.subscriber
-    if cart.completed?
-      end! # you can also invoke `unsubscribe!` to cancel this mailing and all future mailings
+class OnboardingDripper < ApplicationDripper
+  drip :welcome_to_my_cool_app, delay: 0.hours
+  drip :some_cool_tips, delay: 2.days
+  drip :help_getting_started, delay: 3.days do 
+    if mailing.user.company.present?
+      mailing.unsubscribe!
       return false
-    end 
-  end 
+    end
+  end
 end 
 ```
 
-Automatically subscribe eligible carts to it by running:
+### Add a subscriber to the Campaign
 
 ```ruby 
-AbandonedCartDripper.subscribe!
+class User < ApplicationRecord
+  after_create_commit do 
+    Caffeinate::Campaign.find_by(slug: "onboarding").subscribe(self)
+  end 
+end
 ```
 
-This would typically run in a background job, queued up at a given interval.
+### Run the Dripper
 
-And then, once it's done, start your engines!
+You'd normally want to do this in a cron/whenever/scheduled Sidekiq/etc job.
 
-```ruby 
-AbandonedCartDripper.perform!
+```ruby
+OnboardingDripper.perform!
 ```
 
-This, too, would typically run in a background job, queued up at a given interval.
+### Spend more time building
+
+Now you can spend more time building your app and less time managing your marketing campaigns.
+* Centralized logic makes it easy to understand the flow
+* Subscription management, timings, send history all built-in
+* Built on the stack you're already familiar with
+
+There's a lot more than what you just saw, too! Caffeinate almost makes managing timed email sequences fun. 
 
 ## Installation
 
@@ -103,6 +111,11 @@ Followed by a migrate:
 $ rails db:migrate
 ```
 
+## Documentation
+
+* [Getting started, tips and tricks](https://github.com/joshmn/caffeinate/blob/master/docs/README.md) 
+* [Better-than-average code documentation](https://rubydoc.info/github/joshmn/caffeinate)
+
 ## Upcoming features/todo
 
 * Ability to optionally use relative start time when creating a step 

data/app/controllers/caffeinate/campaign_subscriptions_controller.rb

@@ -2,18 +2,33 @@
 
 module Caffeinate
   class CampaignSubscriptionsController < ApplicationController
+    layout 'caffeinate'
+
+    helper_method :caffeinate_unsubscribe_url, :caffeinate_subscribe_url
+
     before_action :find_campaign_subscription!
 
     def unsubscribe
       @campaign_subscription.unsubscribe!
-      render plain: 'You have been unsubscribed.'
+    end
+
+    def subscribe
+      @campaign_subscription.subscribe!
     end
 
     private
 
+    def caffeinate_subscribe_url(**options)
+      Caffeinate::UrlHelpers.caffeinate_subscribe_url(@campaign_subscription, options)
+    end
+
+    def caffeinate_unsubscribe_url
+      Caffeinate::UrlHelpers.caffeinate_unsubscribe_url(@campaign_subscription, options)
+    end
+
     def find_campaign_subscription!
       @campaign_subscription = ::Caffeinate::CampaignSubscription.find_by(token: params[:token])
-      return render plain: '404' if @campaign_subscription.nil?
+      raise ::ActiveRecord::RecordNotFound if @campaign_subscription.nil?
     end
   end
 end

data/app/models/caffeinate/campaign.rb

@@ -1,7 +1,17 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: caffeinate_campaigns
+#
+#  id         :integer          not null, primary key
+#  name       :string           not null
+#  slug       :string           not null
+#  created_at :datetime         not null
+#  updated_at :datetime         not null
+#
 module Caffeinate
-  # Campaign.
+  # Campaign ties together subscribers and mailings, and provides one core model for handling your Drippers.
   class Campaign < ApplicationRecord
     self.table_name = 'caffeinate_campaigns'
     has_many :caffeinate_campaign_subscriptions, class_name: 'Caffeinate::CampaignSubscription', foreign_key: :caffeinate_campaign_id
@@ -12,9 +22,38 @@ module Caffeinate
       Caffeinate.dripper_to_campaign_class[slug.to_sym].constantize
     end
 
+    # Convenience method for find_by!(slug: value)
+    #
+    #   ::Caffeinate::Campaign[:onboarding]
+    #   # is the same as
+    #   ::Caffeinate::Campaign.find_by(slug: :onboarding)
+    def self.[](val)
+      find_by!(slug: val)
+    end
+
+    # Checks to see if the subscriber exists.
+    #
+    # Use `find_by` so that we don't have to load the record twice. Often used with `subscribes?`
+    def subscriber(record, **args)
+      @subscriber ||= caffeinate_campaign_subscriptions.find_by(subscriber: record, **args)
+    end
+
+    # Check if the subscriber exists
+    def subscribes?(record, **args)
+      subscriber(record, **args).present?
+    end
+
     # Subscribes an object to a campaign.
     def subscribe(subscriber, **args)
       caffeinate_campaign_subscriptions.find_or_create_by(subscriber: subscriber, **args)
     end
+
+    # Subscribes an object to a campaign.
+    def subscribe!(subscriber, **args)
+      subscription = subscribe(subscriber, **args)
+      return subscription if subscribe.persisted?
+
+      raise ActiveRecord::RecordInvalid, subscription
+    end
   end
 end

data/app/models/caffeinate/campaign_subscription.rb

@@ -1,12 +1,29 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: caffeinate_campaign_subscriptions
+#
+#  id                     :integer          not null, primary key
+#  caffeinate_campaign_id :integer          not null
+#  subscriber_type        :string           not null
+#  subscriber_id          :string           not null
+#  user_type              :string
+#  user_id                :string
+#  token                  :string           not null
+#  ended_at               :datetime
+#  unsubscribed_at        :datetime
+#  created_at             :datetime         not null
+#  updated_at             :datetime         not null
+#
 module Caffeinate
-  # CampaignSubscription associates an object and its optional user to a Campaign.
+  # CampaignSubscription associates an object and its optional user to a Campaign
+  # and its relevant Mailings.
   class CampaignSubscription < ApplicationRecord
     self.table_name = 'caffeinate_campaign_subscriptions'
 
-    has_many :caffeinate_mailings, class_name: 'Caffeinate::Mailing', foreign_key: :caffeinate_campaign_subscription_id
-    has_one :next_caffeinate_mailing, -> { upcoming.unsent.limit(1).first }, class_name: 'Caffeinate::Mailing', foreign_key: :caffeinate_campaign_subscription_id
+    has_many :caffeinate_mailings, class_name: 'Caffeinate::Mailing', foreign_key: :caffeinate_campaign_subscription_id, dependent: :destroy
+    has_one :next_caffeinate_mailing, -> { upcoming.unsent }, class_name: '::Caffeinate::Mailing', foreign_key: :caffeinate_campaign_subscription_id
     belongs_to :caffeinate_campaign, class_name: 'Caffeinate::Campaign', foreign_key: :caffeinate_campaign_id
     belongs_to :subscriber, polymorphic: true
     belongs_to :user, polymorphic: true, optional: true
@@ -37,12 +54,12 @@ module Caffeinate
       !ended? && !unsubscribed?
     end
 
-    # Checks if the CampaignSubscription is not subscribed
+    # Checks if the CampaignSubscription is not subscribed by checking the presence of `unsubscribed_at`
     def unsubscribed?
-      !subscribed?
+      unsubscribed_at.present?
     end
 
-    # Checks if the CampaignSubscription is ended
+    # Checks if the CampaignSubscription is ended by checking the presence of `ended_at`
     def ended?
       ended_at.present?
     end
@@ -61,6 +78,13 @@ module Caffeinate
       caffeinate_campaign.to_dripper.run_callbacks(:on_unsubscribe, self)
     end
 
+    # Updates `unsubscribed_at` to nil and runs `on_subscribe` callbacks
+    def resubscribe!
+      update!(unsubscribed_at: nil, resubscribed_at: ::Caffeinate.config.time_now)
+
+      caffeinate_campaign.to_dripper.run_callbacks(:on_resubscribe, self)
+    end
+
     private
 
     # Create mailings according to the drips registered in the Campaign

data/app/models/caffeinate/mailing.rb

@@ -1,8 +1,24 @@
 # frozen_string_literal: true
 
+# == Schema Information
+#
+# Table name: caffeinate_mailings
+#
+#  id                                  :integer          not null, primary key
+#  caffeinate_campaign_subscription_id :integer          not null
+#  send_at                             :datetime
+#  sent_at                             :datetime
+#  skipped_at                          :datetime
+#  mailer_class                        :string           not null
+#  mailer_action                       :string           not null
+#  created_at                          :datetime         not null
+#  updated_at                          :datetime         not null
+#
 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'
@@ -49,7 +65,7 @@ module Caffeinate
     # The associated drip
     # @todo This can be optimized with a better cache
     def drip
-      @drip ||= caffeinate_campaign.to_dripper.drips.find { |drip| drip.action.to_s == mailer_action }
+      @drip ||= caffeinate_campaign.to_dripper.drip_collection[mailer_action]
     end
 
     # The associated Subscriber from `::Caffeinate::CampaignSubscription`
@@ -64,7 +80,7 @@ module Caffeinate
 
     # Assigns attributes to the Mailing from the Drip
     def from_drip(drip)
-      self.send_at = drip.options[:delay].from_now
+      self.send_at = drip.send_at
       self.mailer_class = drip.options[:mailer_class]
       self.mailer_action = drip.action
       self

data/app/views/caffeinate/campaign_subscriptions/subscribe.html.erb

@@ -0,0 +1,3 @@
+<%= t("caffeinate.campaign_subscriptions.subscribe") %>
+<p><%= t("caffeinate.campaign_subscriptions.changed_your_mind")%></p>
+<p><%= link_to "Unsubscribe", caffeinate_subscribe_url %></p>

data/app/views/caffeinate/campaign_subscriptions/unsubscribe.html.erb

@@ -0,0 +1,3 @@
+<h5><%= t("caffeinate.campaign_subscriptions.unsubscribe")%></h5>
+<p><%= t("caffeinate.campaign_subscriptions.changed_your_mind")%></p>
+<p><%= link_to "Resubscribe", caffeinate_subscribe_url %></p>

data/app/views/layouts/caffeinate.html.erb

@@ -0,0 +1,11 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title><%= Rails.application.class.module_parent_name %></title>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/locales/en.yml

@@ -0,0 +1,6 @@
+en:
+  caffeinate:
+    campaign_subscriptions:
+      subscribe: "You have been subscribed."
+      unsubscribe: "You have been unsubscribed."
+      changed_your_mind: "Change your mind?"

data/db/migrate/20201124183303_create_caffeinate_campaign_subscriptions.rb

@@ -12,6 +12,7 @@ class CreateCaffeinateCampaignSubscriptions < ActiveRecord::Migration[6.0]
       t.string :user_id
       t.string :token, null: false
       t.datetime :ended_at
+      t.datetime :resubscribed_at
       t.datetime :unsubscribed_at
 
       t.timestamps

data/lib/caffeinate.rb

@@ -3,6 +3,7 @@
 require 'rails/all'
 require 'caffeinate/engine'
 require 'caffeinate/drip'
+require 'caffeinate/url_helpers'
 require 'caffeinate/configuration'
 require 'caffeinate/dripper/base'
 require 'caffeinate/deliver_async'
@@ -27,4 +28,14 @@ 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.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,11 +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[:current_caffeinate_mailing] if Thread.current[:current_caffeinate_mailing]
+          @mailing = Caffeinate.current_mailing if Caffeinate.current_mailing
         end
+
+        klass.helper_method :caffeinate_unsubscribe_url, :caffeinate_subscribe_url
+      end
+
+      # Assumes `@mailing` is set
+      def caffeinate_unsubscribe_url(mailing: nil, **options)
+        mailing ||= @mailing
+        Caffeinate::UrlHelpers.caffeinate_unsubscribe_url(mailing.caffeinate_campaign_subscription, **options)
+      end
+
+      # 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,10 +2,12 @@
 
 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[:current_caffeinate_mailing]
+        mailing = Caffeinate.current_mailing
         return unless mailing
 
         mailing.caffeinate_campaign.to_dripper.run_callbacks(:before_send, mailing.caffeinate_campaign_subscription, mailing, message)

data/lib/caffeinate/action_mailer/observer.rb

@@ -2,14 +2,14 @@
 
 module Caffeinate
   module ActionMailer
-    # Handles updating the Caffeinate::Message if it's available in Thread.current[:current_caffeinate_mailing]
+    # Handles updating the Caffeinate::Message if it's available in Caffeinate.current_mailing
     # and runs any associated callbacks
     class Observer
       def self.delivered_email(message)
-        mailing = Thread.current[:current_caffeinate_mailing]
+        mailing = Caffeinate.current_mailing
         return unless mailing
 
-        mailing.update!(sent_at: Caffeinate.config.time_now) if message.perform_deliveries
+        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)
       end
     end

data/lib/caffeinate/active_record/extension.rb

@@ -2,14 +2,15 @@
 
 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'
+        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, lambda { |list|
+        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)
         }

data/lib/caffeinate/configuration.rb

@@ -1,13 +1,15 @@
 # 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
 
     def initialize
       @now = -> { Time.current }
       @async_delivery = false
       @mailing_job = nil
+      @batch_size = 1_000
     end
 
     def now=(val)

data/lib/caffeinate/drip.rb

@@ -1,40 +1,11 @@
 # frozen_string_literal: true
 
+require 'caffeinate/drip_evaluator'
 module Caffeinate
   # A Drip object
+  #
+  # Handles the block and provides convenience methods for the drip
   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
@@ -43,14 +14,18 @@ module Caffeinate
       @block = block
     end
 
-    # If the associated ActionMailer uses `ActionMailer::Parameterized` initialization
+    # If the associated ActionMailer uses `ActionMailer::Parameterized` initialization instead of argument-based initialization
     def parameterized?
       options[:using] == :parameterized
     end
 
-    # If the drip is enabled.
+    def send_at
+      options[:delay].from_now
+    end
+
+    # Checks if the drip is enabled
     def enabled?(mailing)
-      Evaluator.new(mailing).call(&@block)
+      DripEvaluator.new(mailing).call(&@block)
     end
   end
 end

data/lib/caffeinate/drip_evaluator.rb

@@ -0,0 +1,35 @@
+# 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
+
+    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
+end

data/lib/caffeinate/dripper/base.rb

@@ -1,33 +1,28 @@
 # frozen_string_literal: true
 
-require 'caffeinate/dripper/drip'
+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/subscriber'
 
 module Caffeinate
   module Dripper
+    # Base class
     class Base
+      include Batching
       include Callbacks
       include Campaign
       include Defaults
       include Delivery
       include Drip
+      include Inferences
       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/batching.rb

@@ -0,0 +1,20 @@
+# 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
+      end
+
+      def _batch_size
+        @_batch_size || ::Caffeinate.config.batch_size
+      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,6 +38,56 @@ module Caffeinate
           @on_subscribe_blocks ||= []
         end
 
+        # Callback before the mailings get processed.
+        #
+        #   before_process 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
+        end
+
+        # :nodoc:
+        def before_process_blocks
+          @before_process_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_process(&block)
+          on_process_blocks << block
+        end
+
+        # :nodoc:
+        def on_process_blocks
+          @on_process_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_process(&block)
+          after_process_blocks << block
+        end
+
+        # :nodoc:
+        def after_process_blocks
+          @after_process_blocks ||= []
+        end
+
         # Callback before a Drip has called the mailer.
         #
         #   before_drip do |campaign_subscription, mailing, drip|
@@ -125,8 +180,8 @@ module Caffeinate
         #     Slack.notify(:caffeinate, "#{campaign_sub.id} has unsubscribed... sad day.")
         #   end
         #
-        # @yield Caffeinate::CampaignSubscription
-        # @yield Caffeinate::Mailing
+        # @yield `Caffeinate::CampaignSubscription`
+        # @yield `Caffeinate::Mailing`
         def on_skip(&block)
           on_skip_blocks << block
         end

data/lib/caffeinate/dripper/campaign.rb

@@ -2,6 +2,7 @@
 
 module Caffeinate
   module Dripper
+    # Campaign methods for `Caffeinate::Dripper`.
     module Campaign
       # :nodoc:
       def self.included(klass)
@@ -10,7 +11,7 @@ module Caffeinate
 
       # The campaign for this Dripper
       #
-      # @return Caffeinate::Campaign
+      # @return `Caffeinate::Campaign`
       def campaign
         self.class.caffeinate_campaign
       end
@@ -18,7 +19,7 @@ module Caffeinate
       module ClassMethods
         # Sets the campaign on the Dripper and resets any existing `@caffeinate_campaign`
         #
-        #   class OrdersDripper
+        #   class OrdersDripper < ApplicationDripper
         #     campaign :order_drip
         #   end
         #
@@ -33,19 +34,16 @@ module Caffeinate
           Caffeinate.register_dripper(@_campaign_slug, name)
         end
 
-        # Returns the `Caffeinate::Campaign` object for the Campaign
+        # Returns the `Caffeinate::Campaign` object for the Dripper
         def caffeinate_campaign
           return @caffeinate_campaign if @caffeinate_campaign.present?
 
-          @caffeinate_campaign = ::Caffeinate::Campaign.find_by(slug: campaign_slug)
-          return @caffeinate_campaign if @caffeinate_campaign
-
-          raise(::ActiveRecord::RecordNotFound, "Unable to find ::Caffeinate::Campaign with slug #{campaign_slug}.")
+          @caffeinate_campaign = ::Caffeinate::Campaign[campaign_slug]
         end
 
         # The defined slug or the inferred slug
         def campaign_slug
-          @_campaign_slug || name.delete_suffix('Campaign')
+          @_campaign_slug || inferred_campaign_slug
         end
       end
     end

data/lib/caffeinate/dripper/defaults.rb

@@ -2,6 +2,7 @@
 
 module Caffeinate
   module Dripper
+    # Handles the default DSL for a `Caffeinate::Dripper`.
     module Defaults
       # :nodoc:
       def self.included(klass)
@@ -11,7 +12,7 @@ module Caffeinate
       module ClassMethods
         # The defaults set in the Campaign
         def defaults
-          @defaults ||= { mailer_class: inferred_mailer_class }
+          @defaults ||= { mailer_class: inferred_mailer_class, batch_size: ::Caffeinate.config.batch_size }
         end
 
         # The default options for the Campaign
@@ -23,7 +24,7 @@ module Caffeinate
         # @param [Hash] options The options to set defaults with
         # @option options [String] :mailer_class The mailer class
         def default(options = {})
-          options.assert_valid_keys(:mailer_class, :mailer)
+          options.assert_valid_keys(:mailer_class, :mailer, :using, :batch_size)
           @defaults = options
         end
       end

data/lib/caffeinate/dripper/delivery.rb

@@ -2,7 +2,7 @@
 
 module Caffeinate
   module Dripper
-    # Handles delivery of a Caffeinate::Mailer for a Caffeinate::Dripper
+    # Handles delivery of a `Caffeinate::Mailer` for a `Caffeinate::Dripper`.
     module Delivery
       # :nodoc:
       def self.included(klass)
@@ -14,7 +14,7 @@ module Caffeinate
         #
         # @param [Caffeinate::Mailing] mailing The mailing to deliver
         def deliver!(mailing)
-          Thread.current[:current_caffeinate_mailing] = mailing
+          Caffeinate.current_mailing = mailing
 
           if mailing.drip.parameterized?
             mailing.mailer_class.constantize.with(mailing: mailing).send(mailing.mailer_action).deliver

data/lib/caffeinate/dripper/drip.rb

@@ -2,7 +2,7 @@
 
 module Caffeinate
   module Dripper
-    # The Drip DSL for registering a drip
+    # The Drip DSL for registering a drip.
     module Drip
       # A collection of Drip objects for a `Caffeinate::Dripper`
       class DripCollection
@@ -10,21 +10,29 @@ module Caffeinate
 
         def initialize(dripper)
           @dripper = dripper
-          @drips = []
+          @drips = {}
         end
 
         # Register the drip
         def register(action, options, &block)
-          @drips << ::Caffeinate::Drip.new(@dripper, action, options, &block)
+          @drips[action.to_s] = ::Caffeinate::Drip.new(@dripper, action, options, &block)
         end
 
         def each(&block)
-          @drips.each { |drip| block.call(drip) }
+          @drips.each { |action_name, drip| block.call(action_name, drip) }
+        end
+
+        def values
+          @drips.values
         end
 
         def size
           @drips.size
         end
+
+        def [](val)
+          @drips[val]
+        end
       end
 
       # :nodoc:
@@ -33,9 +41,14 @@ module Caffeinate
       end
 
       module ClassMethods
+        # A collection of Drip objects associated with a given `Caffeinate::Dripper`
+        def drip_collection
+          @drip_collection ||= DripCollection.new(self)
+        end
+
         # A collection of Drip objects associated with a given `Caffeinate::Dripper`
         def drips
-          @drips ||= DripCollection.new(self)
+          drip_collection.values
         end
 
         # Register a drip on the Dripper
@@ -50,6 +63,7 @@ module Caffeinate
         def drip(action_name, options = {}, &block)
           options.assert_valid_keys(:mailer_class, :step, :delay, :using, :mailer)
           options[:mailer_class] ||= options[:mailer] || defaults[:mailer_class]
+          options[:using] ||= defaults[:using]
           options[:step] ||= drips.size + 1
 
           if options[:mailer_class].nil?
@@ -57,7 +71,7 @@ module Caffeinate
           end
           raise ArgumentError, "You must define :delay in the options for :#{action_name}" if options[:delay].nil?
 
-          drips.register(action_name, options, &block)
+          drip_collection.register(action_name, options, &block)
         end
       end
     end

data/lib/caffeinate/dripper/inferences.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  module Dripper
+    # Includes the inferred methods based on a Dripper name.
+    module Inferences
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+        # The inferred mailer class
+        def 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
+
+        # The inferred mailer class
+        def inferred_campaign_slug
+          name.delete_suffix('Dripper').to_s.underscore
+        end
+      end
+    end
+  end
+end

data/lib/caffeinate/dripper/perform.rb

@@ -2,7 +2,7 @@
 
 module Caffeinate
   module Dripper
-    # Handles delivering a `Caffeinate::Mailing` for the `Caffeinate::Dripper`
+    # Handles delivering a `Caffeinate::Mailing` for the `Caffeinate::Dripper`.
     module Perform
       # :nodoc:
       def self.included(klass)
@@ -11,14 +11,21 @@ module Caffeinate
 
       # Delivers the next_caffeinate_mailer for the campaign's subscribers.
       #
+      # Handles with batches based on batch_size.
+      #
       #   OrderDripper.new.perform!
       #
       # @return nil
       def perform!
-        campaign.caffeinate_campaign_subscriptions.joins(:next_caffeinate_mailing).includes(:next_caffeinate_mailing).each do |subscriber|
-          subscriber.next_caffeinate_mailing.process!
+        run_callbacks(:before_process, self)
+        campaign.caffeinate_campaign_subscriptions.active.in_batches(of: self.class._batch_size).each do |batch|
+          run_callbacks(:on_process, self, batch)
+          batch.each do |subscriber|
+            subscriber.next_caffeinate_mailing&.process!
+          end
         end
-        true
+        run_callbacks(:after_process, self)
+        nil
       end
 
       module ClassMethods

data/lib/caffeinate/dripper/subscriber.rb

@@ -30,8 +30,8 @@ module Caffeinate
         # @option [ActiveRecord::Base] :user The associated user (optional)
         #
         # @return [Caffeinate::CampaignSubscriber] the created CampaignSubscriber
-        def subscribe(subscriber, user:)
-          caffeinate_campaign.subscribe(subscriber, user: user)
+        def subscribe(subscriber, **args)
+          caffeinate_campaign.subscribe(subscriber, **args)
         end
 
         # :nodoc:

data/lib/caffeinate/engine.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require 'caffeinate/helpers'
 require 'caffeinate/action_mailer'
 require 'caffeinate/active_record/extension'
 
 module Caffeinate
-  # :nodoc:
+  # Adds Caffeinate to Rails
   class Engine < ::Rails::Engine
     isolate_namespace Caffeinate
+    config.eager_load_namespaces << Caffeinate
 
     ActiveSupport.on_load(:action_mailer) do
       include ::Caffeinate::ActionMailer::Extension
@@ -17,5 +19,9 @@ module Caffeinate
     ActiveSupport.on_load(:active_record) do
       extend ::Caffeinate::ActiveRecord::Extension
     end
+
+    ActiveSupport.on_load(:action_view) do
+      ApplicationHelper.include ::Caffeinate::Helpers
+    end
   end
 end

data/lib/caffeinate/helpers.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # URL helpers for accessing the mounted Caffeinate instance.
+  module Helpers
+    def caffeinate_unsubscribe_url(subscription, **options)
+      opts = (::ActionMailer::Base.default_url_options || {}).merge(options)
+      Caffeinate::Engine.routes.url_helpers.unsubscribe_campaign_subscription_url(token: subscription.token, **opts)
+    end
+
+    def caffeinate_subscribe_url(subscription, **options)
+      opts = (::ActionMailer::Base.default_url_options || {}).merge(options)
+      Caffeinate::Engine.routes.url_helpers.subscribe_campaign_subscription_url(token: subscription.token, **opts)
+    end
+
+    def caffeinate_unsubscribe_path(subscription, **options)
+      Caffeinate::Engine.routes.url_helpers.unsubscribe_campaign_subscription_path(token: subscription.token, **options)
+    end
+
+    def caffeinate_subscribe_path(subscription, **options)
+      Caffeinate::Engine.routes.url_helpers.subscribe_campaign_subscription_path(token: subscription.token, **options)
+    end
+  end
+end

data/lib/caffeinate/url_helpers.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'caffeinate/helpers'
+
+module Caffeinate
+  # Convenience class for the URL helpers.
+  class UrlHelpers
+    extend Helpers
+  end
+end

data/lib/caffeinate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Caffeinate
-  VERSION = '0.1.1'
+  VERSION = '0.2.1'
 end

data/lib/generators/caffeinate/install_generator.rb

@@ -2,7 +2,7 @@
 
 module Caffeinate
   module Generators
-    # :nodoc:
+    # Installs Caffeinate
     class InstallGenerator < Rails::Generators::Base
       source_root File.expand_path('templates', __dir__)
       include ::Rails::Generators::Migration
@@ -19,6 +19,10 @@ module Caffeinate
         template 'application_dripper.rb', 'app/drippers/application_dripper.rb'
       end
 
+      def install_routes
+        inject_into_file 'config/routes.rb', "\n  mount ::Caffeinate::Engine => '/caffeinate", after: /Rails.application.routes.draw do/
+      end
+
       # :nodoc:
       def self.next_migration_number(_path)
         if @prev_migration_nr

data/lib/generators/caffeinate/templates/caffeinate.rb

@@ -6,7 +6,7 @@ Caffeinate.setup do |config|
   # Used for when we set a datetime column to "now" in the database
   #
   # Default:
-  #   -> { Time.current }
+  #   config.now = -> { Time.current }
   #
   # config.now = -> { DateTime.now }
   #
@@ -21,4 +21,14 @@ Caffeinate.setup do |config|
   #
   # config.async_delivery = true
   # config.mailing_job = 'MyCustomCaffeinateJob'
+  #
+  # == Batching
+  #
+  # When a Dripper is performed and sends the mails, we use `find_in_batches`. Use `batch_size` to set the batch size.
+  # You can set this on a dripper as well for more granular control.
+  #
+  # Default:
+  #   config.batch_size = 1_000
+  #
+  # config.batch_size = 100
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: caffeinate
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Josh Brody
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-27 00:00:00.000000000 Z
+date: 2020-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -124,8 +124,10 @@ files:
 - app/models/caffeinate/campaign.rb
 - app/models/caffeinate/campaign_subscription.rb
 - app/models/caffeinate/mailing.rb
-- app/views/layouts/caffeinate/application.html.erb
-- app/views/layouts/caffeinate/campaign_subscriptions/unsubscribe.html.erb
+- app/views/caffeinate/campaign_subscriptions/subscribe.html.erb
+- app/views/caffeinate/campaign_subscriptions/unsubscribe.html.erb
+- app/views/layouts/caffeinate.html.erb
+- config/locales/en.yml
 - config/routes.rb
 - db/migrate/20201124183102_create_caffeinate_campaigns.rb
 - db/migrate/20201124183303_create_caffeinate_campaign_subscriptions.rb
@@ -133,25 +135,29 @@ files:
 - lib/caffeinate.rb
 - lib/caffeinate/action_mailer.rb
 - lib/caffeinate/action_mailer/extension.rb
-- lib/caffeinate/action_mailer/helpers.rb
 - lib/caffeinate/action_mailer/interceptor.rb
 - lib/caffeinate/action_mailer/observer.rb
 - lib/caffeinate/active_record/extension.rb
 - lib/caffeinate/configuration.rb
 - lib/caffeinate/deliver_async.rb
 - lib/caffeinate/drip.rb
+- lib/caffeinate/drip_evaluator.rb
 - lib/caffeinate/dripper/base.rb
+- lib/caffeinate/dripper/batching.rb
 - lib/caffeinate/dripper/callbacks.rb
 - lib/caffeinate/dripper/campaign.rb
 - lib/caffeinate/dripper/defaults.rb
 - lib/caffeinate/dripper/delivery.rb
 - lib/caffeinate/dripper/drip.rb
+- lib/caffeinate/dripper/inferences.rb
 - lib/caffeinate/dripper/perform.rb
 - lib/caffeinate/dripper/subscriber.rb
 - lib/caffeinate/engine.rb
+- lib/caffeinate/helpers.rb
+- lib/caffeinate/url_helpers.rb
 - lib/caffeinate/version.rb
 - lib/generators/caffeinate/install_generator.rb
-- lib/generators/caffeinate/templates/application_campaign.rb
+- lib/generators/caffeinate/templates/application_dripper.rb
 - lib/generators/caffeinate/templates/caffeinate.rb
 homepage: https://github.com/joshmn/caffeinate
 licenses:

data/app/views/layouts/caffeinate/application.html.erb

@@ -1,15 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-  <title>Caffeinate</title>
-  <%= csrf_meta_tags %>
-  <%= csp_meta_tag %>
-
-  <%= stylesheet_link_tag    "caffeinate/application", media: "all" %>
-</head>
-<body>
-
-<%= yield %>
-
-</body>
-</html>

data/app/views/layouts/caffeinate/campaign_subscriptions/unsubscribe.html.erb

@@ -1 +0,0 @@
-<h5>You have been unsubscribed.</h5>

data/lib/caffeinate/action_mailer/helpers.rb

@@ -1,12 +0,0 @@
-# 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