caffeinate 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 28eb7e2e3a7a394e841eb4fe5a326ca72725281ffe804a4578e7f96bf25ab07b
+  data.tar.gz: 9bac101dc1c3d534d2df59f3befe6e57caa5fc382569e44ce640d8b0592e8342
+SHA512:
+  metadata.gz: f127818a38285471e57cd97a25d1ed9496dcaa7e464cbd75b6641bd513afcde870ce7e71c2afefc56c00d6f8999a29ee0d3638ac865c4077d592f94d6a216bbe
+  data.tar.gz: f94a837c0d8a1669acb8b962d056d41c82f1b9ce02464674dab2038349fa9d16c1b7c5d4bf5b8ac7dd0bf46d6f167855f0eb55b44d51c8f6982466f8aee08c7b

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Josh Brody
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,125 @@
+# Caffeinate
+
+A drip mailer and management for Ruby on Rails.
+
+## Docs
+
+[Since you asked](https://rubydoc.info/github/joshmn/caffeinate).
+
+## Usage
+
+Given a mailer like this:
+
+```ruby 
+class AbandonedCartMailer < ActionMailer::Base 
+  def you_forgot_something(cart)
+    mail(to: cart.user.email, subject: "You forgot something!")
+  end
+
+  def selling_out_soon(cart)
+    mail(to: cart.user.email, subject: "Selling out soon!")
+  end 
+end 
+```
+
+### Create a Campaign
+
+```ruby 
+Caffeinate::Campaign.create!(name: "Abandoned Cart", slug: "abandoned_cart") 
+```
+
+### Create a Caffeinate::Dripper
+
+```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
+      return false
+    end 
+  end 
+end 
+```
+
+Automatically subscribe eligible carts to it by running:
+
+```ruby 
+AbandonedCartDripper.subscribe!
+```
+
+This would typically run in a background job, queued up at a given interval.
+
+And then, once it's done, start your engines!
+
+```ruby 
+AbandonedCartDripper.perform!
+```
+
+This, too, would typically run in a background job, queued up at a given interval.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'caffeinate'
+```
+
+And then do the bundle:
+
+```bash
+$ bundle
+```
+
+Add do some housekeeping:
+
+```bash
+$ rails g caffeinate:install 
+```
+
+Followed by a migrate:
+
+```bash
+$ rails db:migrate
+```
+
+## Upcoming features/todo
+
+* Ability to optionally use relative start time when creating a step 
+* Logo
+* Conversion tracking
+* Custom field support on CampaignSubscription
+* GUI (?)
+* REST API (?)
+
+## Contributing
+
+Just do it.
+
+## Contributors & thanks
+
+* Thanks to [sourdoughdev](https://github.com/sourdoughdev/caffeinate) for releasing the gem name to me. :) 
+ 
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Caffeinate'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'

data/app/controllers/caffeinate/application_controller.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # :nodoc:
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+  end
+end

data/app/controllers/caffeinate/campaign_subscriptions_controller.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  class CampaignSubscriptionsController < ApplicationController
+    before_action :find_campaign_subscription!
+
+    def unsubscribe
+      @campaign_subscription.unsubscribe!
+      render plain: 'You have been unsubscribed.'
+    end
+
+    private
+
+    def find_campaign_subscription!
+      @campaign_subscription = ::Caffeinate::CampaignSubscription.find_by(token: params[:token])
+      return render plain: '404' if @campaign_subscription.nil?
+    end
+  end
+end

data/app/models/caffeinate/application_record.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # :nodoc:
+  class ApplicationRecord < ::ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/caffeinate/campaign.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # Campaign.
+  class Campaign < ApplicationRecord
+    self.table_name = 'caffeinate_campaigns'
+    has_many :caffeinate_campaign_subscriptions, class_name: 'Caffeinate::CampaignSubscription', foreign_key: :caffeinate_campaign_id
+    has_many :caffeinate_mailings, through: :caffeinate_campaign_subscriptions, class_name: 'Caffeinate::CampaignSubscriptions'
+
+    # Poorly-named Campaign class resolver
+    def to_dripper
+      Caffeinate.dripper_to_campaign_class[slug.to_sym].constantize
+    end
+
+    # Subscribes an object to a campaign.
+    def subscribe(subscriber, **args)
+      caffeinate_campaign_subscriptions.find_or_create_by(subscriber: subscriber, **args)
+    end
+  end
+end

data/app/models/caffeinate/campaign_subscription.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # CampaignSubscription associates an object and its optional user to a Campaign.
+  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
+    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
+
+    # All CampaignSubscriptions that where `unsubscribed_at` is nil and `ended_at` is nil
+    scope :active, -> { where(unsubscribed_at: nil, ended_at: nil) }
+
+    # All CampaignSubscriptions that where `unsubscribed_at` is nil and `ended_at` is nil
+    scope :subscribed, -> { active }
+
+    scope :unsubscribed, -> { where.not(unsubscribed_at: nil) }
+
+    # All CampaignSubscriptions that where `ended_at` is not nil
+    scope :ended, -> { where.not(ended_at: nil) }
+
+    before_validation :set_token!, on: [:create]
+    validates :token, uniqueness: true, on: [:create]
+
+    after_commit :create_mailings!, on: :create
+
+    # Actually deliver and process the mail
+    def deliver!(mailing)
+      caffeinate_campaign.to_dripper.deliver!(mailing)
+    end
+
+    # Checks if the subscription is not ended and not unsubscribed
+    def subscribed?
+      !ended? && !unsubscribed?
+    end
+
+    # Checks if the CampaignSubscription is not subscribed
+    def unsubscribed?
+      !subscribed?
+    end
+
+    # Checks if the CampaignSubscription is ended
+    def ended?
+      ended_at.present?
+    end
+
+    # Updates `ended_at` and runs `on_complete` callbacks
+    def end!
+      update!(ended_at: ::Caffeinate.config.time_now)
+
+      caffeinate_campaign.to_dripper.run_callbacks(:on_complete, self)
+    end
+
+    # Updates `unsubscribed_at` and runs `on_subscribe` callbacks
+    def unsubscribe!
+      update!(unsubscribed_at: ::Caffeinate.config.time_now)
+
+      caffeinate_campaign.to_dripper.run_callbacks(:on_unsubscribe, self)
+    end
+
+    private
+
+    # Create mailings according to the drips registered in the Campaign
+    def create_mailings!
+      caffeinate_campaign.to_dripper.drips.each do |drip|
+        mailing = Caffeinate::Mailing.new(caffeinate_campaign_subscription: self).from_drip(drip)
+        mailing.save!
+      end
+      caffeinate_campaign.to_dripper.run_callbacks(:on_subscribe, self)
+    end
+
+    def set_token!
+      loop do
+        self.token = SecureRandom.uuid
+        break unless self.class.exists?(token: token)
+      end
+    end
+  end
+end

data/app/models/caffeinate/mailing.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Caffeinate
+  # Records of the mails sent and to be sent for a given `::Caffeinate::CampaignSubscriber`
+  class Mailing < ApplicationRecord
+    self.table_name = 'caffeinate_mailings'
+
+    belongs_to :caffeinate_campaign_subscription, class_name: 'Caffeinate::CampaignSubscription'
+    has_one :caffeinate_campaign, through: :caffeinate_campaign_subscription
+
+    scope :upcoming, -> { unsent.unskipped.where('send_at < ?', ::Caffeinate.config.time_now).order('send_at asc') }
+    scope :unsent, -> { unskipped.where(sent_at: nil) }
+    scope :sent, -> { unskipped.where.not(sent_at: nil) }
+    scope :skipped, -> { where.not(skipped_at: nil) }
+    scope :unskipped, -> { where(skipped_at: nil) }
+
+    # Checks if the Mailing is not skipped and not sent
+    def pending?
+      unskipped? && unsent?
+    end
+
+    # Checks if the Mailing is skipped
+    def skipped?
+      skipped_at.present?
+    end
+
+    # Checks if the Mailing is not skipped
+    def unskipped?
+      !skipped?
+    end
+
+    # Checks if the Mailing is sent
+    def sent?
+      sent_at.present?
+    end
+
+    # Checks if the Mailing is not sent
+    def unsent?
+      !sent?
+    end
+
+    # Updates `skipped_at and runs `on_skip` callbacks
+    def skip!
+      update!(skipped_at: Caffeinate.config.time_now)
+
+      caffeinate_campaign.to_dripper.run_callbacks(:on_skip, caffeinate_campaign_subscription, self)
+    end
+
+    # 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 }
+    end
+
+    # The associated Subscriber from `::Caffeinate::CampaignSubscription`
+    def subscriber
+      caffeinate_campaign_subscription.subscriber
+    end
+
+    # The associated Subscriber from `::Caffeinate::CampaignSubscription`
+    def user
+      caffeinate_campaign_subscription.user
+    end
+
+    # Assigns attributes to the Mailing from the Drip
+    def from_drip(drip)
+      self.send_at = drip.options[:delay].from_now
+      self.mailer_class = drip.options[:mailer_class]
+      self.mailer_action = drip.action
+      self
+    end
+
+    # Handles the logic for delivery and delivers
+    def process!
+      if ::Caffeinate.config.async_delivery?
+        deliver_later!
+      else
+        deliver!
+      end
+    end
+
+    # Delivers the Mailing in the foreground
+    def deliver!
+      caffeinate_campaign_subscription.deliver!(self)
+    end
+
+    # Delivers the Mailing in the background
+    def deliver_later!
+      klass = ::Caffeinate.config.mailing_job_class
+      if klass.respond_to?(:perform_later)
+        klass.perform_later(id)
+      elsif klass.respond_to?(:perform_async)
+        klass.perform_async(id)
+      else
+        raise NoMethodError, "Neither perform_later or perform_async are defined on #{klass}."
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+<!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

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

data/config/routes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+Caffeinate::Engine.routes.draw do
+  resources :campaign_subscriptions, only: [], param: :token do
+    member do
+      get :unsubscribe
+      get :subscribe
+    end
+  end
+end