boutique 0.0.11 → 0.1.0

data/lib/boutique/app.rb

@@ -0,0 +1,60 @@
+module Boutique
+  class App < Sinatra::Base
+    set :logging, true
+    set :raise_errors, false
+    set :show_exceptions, false
+
+    error do
+      err = request.env['sinatra.error']
+      Pony.mail(
+        :to => Boutique.config.error_email,
+        :subject => "[Boutique Error] #{err.message}",
+        :body => [request.env.to_s, err.message, err.backtrace].compact.flatten.join("\n")
+      ) if Boutique.config.error_email
+      raise err
+    end
+
+    get '/subscribe/:list_key' do
+      list = get_list(params[:list_key])
+      begin
+        subscriber = Subscriber.find_or_create(
+          list_key: list.key,
+          email: params[:email])
+        Emailer.new(list).deliver_zero(subscriber) rescue nil
+        jsonp
+      rescue Sequel::ValidationFailed => e
+        halt 400, e.message
+      end
+    end
+
+    get '/confirm/:list_key/:id/:secret' do
+      list = get_list(params[:list_key])
+      subscriber = get_subscriber(params[:id], list, params[:secret])
+      subscriber.confirm!(params[:secret])
+      jsonp
+    end
+
+    get '/unsubscribe/:list_key/:id/:secret' do
+      list = get_list(params[:list_key])
+      subscriber = get_subscriber(params[:id], list, params[:secret])
+      subscriber.unconfirm!(params[:secret])
+      jsonp
+    end
+
+    private
+    def jsonp
+      params[:jsonp].nil? ? '' : "#{params[:jsonp]}()"
+    end
+
+    def get_list(list_key)
+      List[list_key] || halt(404)
+    end
+
+    def get_subscriber(id, list, secret)
+      Subscriber.first(
+        id: params[:id],
+        list_key: list.key,
+        secret: secret) || halt(404)
+    end
+  end
+end

data/lib/boutique/config.rb

@@ -0,0 +1,101 @@
+module Boutique
+  class << self
+    attr_accessor :database
+
+    def configure
+      yield config
+      Pony.options = config.email_options if !config.email_options.nil?
+      Boutique.database = Sequel.connect(config.db_options)
+      require_relative 'model'
+    end
+
+    def config
+      @config ||= Config.new('config')
+    end
+
+    def product(key)
+      yield Product.new(key)
+    end
+
+    def list(key)
+      yield List.new(key)
+    end
+  end
+
+  module MemoryResource
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.attr_resource :key
+      base.reset_db
+    end
+
+    module ClassMethods
+      def attr_resource(*names)
+        names.each do |name|
+          define_method(name) do |*args|
+            value = args[0]
+            instance_variable_set("@#{name}".to_sym, value) if !value.nil?
+            instance_variable_get("@#{name}".to_sym)
+          end
+        end
+      end
+
+      def reset_db
+        @db = {}
+      end
+
+      def [](key)
+        @db[key]
+      end
+
+      def []=(key, value)
+        @db[key] = value
+      end
+
+      def include?(key)
+        self.to_a.include?(key)
+      end
+
+      def to_a
+        @db.keys
+      end
+    end
+
+    def initialize(key)
+      @key = key
+      self.class[key] = self
+    end
+  end
+
+  class Config
+    include MemoryResource
+    attr_resource :error_email,
+      :stripe_api_key,
+      :download_dir,
+      :download_path,
+      :db_options,
+      :email_options
+  end
+
+  class Product
+    include MemoryResource
+    attr_resource :from, :files, :price
+  end
+
+  class List
+    include MemoryResource
+    attr_resource :from, :emails, :url
+
+    def subscribers
+      Subscriber.where(list_key: self.key)
+    end
+
+    def subscribe_url
+      url = URI.parse(self.url)
+      params = [url.query]
+      params << "boutique=subscribe/#{CGI.escape(self.key)}"
+      url.query = params.compact.join('&')
+      url.to_s
+    end
+  end
+end

data/lib/boutique/emailer.rb

@@ -0,0 +1,109 @@
+module Boutique
+  class Emailer
+    def initialize(list, directory = nil)
+      @list = list
+      @directory = directory
+    end
+
+    def render(path, locals = {}, pre = false)
+      path = @directory ?
+        File.join(@directory, path) :
+        full_path(path)
+      raise "File not found: #{path}" if !File.exist?(path)
+
+      yaml, body = preamble(path)
+      templates_for(path).each do |template|
+        blk = proc { body }
+        body = template.new(path, &blk).render(self, locals)
+      end
+
+      pre ? [yaml, body] : body
+    end
+
+    def deliver(subscriber, path, locals = {})
+      locals = locals.merge(
+        subscribe_url: @list.subscribe_url,
+        confirm_url: subscriber.confirm_url,
+        unsubscribe_url: subscriber.unsubscribe_url)
+      yaml, body = self.render(path, locals, true)
+      if yaml['day'] == 0
+        ymd = Date.today.strftime("%Y-%m-%d")
+        Email.create(email_key: "#{yaml['key']}-#{ymd}", subscriber: subscriber)
+      else
+        raise "Unconfirmed #{subscriber.email} for #{yaml['key']}" if !subscriber.confirmed
+        Email.create(email_key: yaml['key'], subscriber: subscriber)
+      end
+      Pony.mail(
+        to: subscriber.email,
+        from: @list.from,
+        subject: yaml['subject'],
+        headers: {'Content-Type' => 'text/html'},
+        body: body)
+    rescue DataMapper::SaveFailureError
+      raise "Duplicate email #{yaml['key']} to #{subscriber.email}"
+    end
+
+    def deliver_zero(subscriber)
+      self.deliver(subscriber, emails[0])
+    end
+
+    def blast(path, locals = {})
+      yaml, body = preamble(full_path(path))
+      email_key = yaml['key']
+      @list.subscribers.where(confirmed: true).each do |subscriber|
+        # TODO: speed up by moving filter outside of loop
+        if Email.first(email_key: yaml['key'], subscriber: subscriber).nil?
+          self.deliver(subscriber, path, locals)
+        end
+      end
+    end
+
+    def drip
+      today = Date.today
+      max_day = emails.keys.max || 0
+      subscribers = @list.subscribers.
+        where(confirmed: true).
+        where { (drip_on < today) & (drip_day < max_day) }
+      subscribers.each do |subscriber|
+        subscriber.drip_on = today
+        subscriber.drip_day += 1
+        subscriber.save
+        if (email_path = emails[subscriber.drip_day])
+          self.deliver(subscriber, email_path)
+        end
+      end
+    end
+
+    private
+    def full_path(path)
+      File.join(@list.emails, path)
+    end
+
+    def templates_for(path)
+      basename = File.basename(path)
+      basename.split('.')[1..-1].reverse.map { |ext| Tilt[ext] }
+    end
+
+    def emails
+      @emails ||= begin
+        emails = {}
+        Dir.entries(@list.emails).each do |filename|
+          next if File.directory?(filename)
+          # TODO: stop duplicating calls to preamble, store in memory
+          yaml, body = preamble(full_path(filename))
+          if yaml && yaml['day'] && yaml['key']
+            emails[yaml['day']] = filename
+          end
+        end
+        emails
+      end
+    end
+
+    def preamble(path)
+      data = Preamble.load(path)
+      [data.metadata, data.content]
+    rescue
+      [{}, File.read(path)]
+    end
+  end
+end

data/lib/boutique/model.rb

@@ -0,0 +1,86 @@
+module Boutique
+  class Migrate
+    def self.run
+      Sequel.extension :migration
+      Sequel::Migrator.run(Boutique.database, File.join(File.dirname(__FILE__), '..', '..', 'migrate'))
+      # re-parse the schema after table changes
+      Subscriber.dataset = Subscriber.dataset
+      Email.dataset = Email.dataset
+    end
+  end
+
+  class Subscriber < Sequel::Model
+    one_to_many :emails
+    set_allowed_columns :list_key, :email
+
+    def initialize(*args)
+      super
+      self.secret ||= SecureRandom.hex(3)
+      self.drip_on ||= Date.today
+      self.created_at ||= DateTime.now
+    end
+
+    def validate
+      super
+      errors.add(:list_key, 'is invalid') if !List.include?(list_key)
+      errors.add(:email, 'is invalid') if email !~ /\A([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})\Z/i
+
+      count = self.class.
+        where(list_key: list_key, email: email).
+        exclude(id: id).
+        count
+      errors.add(:email, 'has already subscribed') if count > 0
+    end
+
+    def list
+      @list ||= List[self.list_key]
+    end
+
+    def confirm!(secret)
+      self.confirmed = true if self.secret == secret
+      self.save
+    end
+
+    def unconfirm!(secret)
+      self.confirmed = false if self.secret == secret
+      self.save
+    end
+
+    def confirm_url
+      secret_url("confirm")
+    end
+
+    def unsubscribe_url
+      secret_url("unsubscribe")
+    end
+
+    private
+    def secret_url(action)
+      url = URI.parse(self.list.url)
+      params = [url.query]
+      params << "boutique=#{action}/#{CGI.escape(self.list_key)}/#{self.id}/#{self.secret}"
+      url.query = params.compact.join('&')
+      url.to_s
+    end
+  end
+
+  class Email < Sequel::Model
+    many_to_one :subscriber
+
+    def initialize(*args)
+      super
+      self.created_at ||= DateTime.now
+    end
+
+    def validate
+      super
+      errors.add(:subscriber_id, "can't be blank") if subscriber_id.nil?
+
+      count = self.class.
+        where(subscriber_id: subscriber_id, email_key: email_key).
+        exclude(id: id).
+        count
+      errors.add(:email_key, 'has already been sent') if count > 0
+    end
+  end
+end

data/lib/boutique/version.rb

@@ -0,0 +1,3 @@
+module Boutique
+  VERSION = '0.1.0'
+end

data/migrate/001_init_schema.rb

@@ -0,0 +1,21 @@
+Sequel.migration do
+  change do
+    create_table(:subscribers) do
+      primary_key :id
+      column :list_key, String, null: false
+      column :email, String, null: false
+      column :secret, String, null: false
+      column :confirmed, TrueClass, null: false, default: false
+      column :created_at, DateTime, null: false
+      column :drip_on, Date, null: false
+      column :drip_day, Integer, null: false, default: 0
+    end
+
+    create_table(:emails) do
+      primary_key :id
+      foreign_key :subscriber_id, :subscribers
+      column :email_key, String, null: false
+      column :created_at, DateTime, null: false
+    end
+  end
+end

data/public/boutique/script.js

@@ -0,0 +1,144 @@
+var Boutique = {
+  URL: "/boutique/",
+  lists: {},
+  subscribe: function(key) {
+    var modal = this.buildModal(key);
+    modal.show();
+    $("body").css("overflow-y", "hidden");
+    if (modal.hasClass("unsubscribed")) {
+      modal.removeClass("unsubscribed").addClass("start");
+    }
+    return modal;
+  },
+  showModal: function(key, action) {
+    var modal = Boutique.buildModal(key);
+    var state = {confirm: "confirmed", unsubscribe: "unsubscribed"}[action];
+    modal.removeClass("start subscribed confirmed unsubscribed");
+    modal.addClass(state);
+    modal.show();
+    $("body").css("overflow-y", "hidden");
+  },
+  hideModal: function() {
+    $(".boutique").hide();
+    $("body").css("overflow-y", "auto");
+  },
+  list: function(key, configs) {
+    this.lists[key] = configs;
+    var params = this.params("boutique");
+    if (params) {
+      params = params.split("/");
+      var pAction = params[0];
+      var pKey = params[1];
+      var pId = params[2];
+      var pSecret = params[3];
+      if (key == pKey && pAction == "subscribe") {
+        Boutique.subscribe(key);
+      } else if (key == pKey && ($.inArray(pAction, ["subscribe", "unsubscribe"]))) {
+        if (document.domain == "localhost" && pId == "0") {
+          Boutique.showModal(key, pAction);
+        } else {
+          $.ajax(this.URL + pAction + "/" + key + "/" + pId + "/" + pSecret, {
+            dataType: "jsonp",
+            jsonp: "jsonp",
+            success: function() {
+              Boutique.showModal(key, pAction);
+            }
+          });
+        }
+      }
+    }
+  },
+  buildModal: function(key) {
+    var modal = $("#boutique-list-" + key);
+    if (modal.length) { return modal; }
+
+    var html = "";
+    html += '<div class="boutique start">';
+    html += '  <div class="boutique-modal">';
+    html += '    <div class="boutique-close">&times;</div>';
+    html += '  </div>';
+    html += '</div>';
+
+    modal = $(html);
+    modal.click(function(e) {
+      if (e.target != this) { return; }
+      e.preventDefault();
+      Boutique.hideModal();
+    });
+    modal.find(".boutique-close").click(function(e) {
+      e.preventDefault();
+      Boutique.hideModal();
+    });
+    modal.attr("id", "boutique-list-" + key);
+
+    var states = ["start", "subscribed", "confirmed", "unsubscribed"];
+    for (var i = 0; i < states.length; i++) {
+      var state = states[i];
+      var head = $('<div class="boutique-head '+ state +'"></div>');
+      var body = $('<div class="boutique-body '+ state +'"></div>');
+      head.html(this.lists[key][state]["title"]);
+      body.html(this.lists[key][state]["body"]);
+      if (state == "start") {
+        body.append(this.buildSubscribeForm(key));
+      } else if (this.lists[key][state]["button"]) {
+        body.append(this.buildButton(key, state));
+      }
+      modal.find(".boutique-modal").prepend(head, body);
+    }
+    $("body").append(modal);
+    return modal;
+  },
+  buildSubscribeForm: function(key) {
+    var html = "";
+    html += '<form>';
+    html += '  <p>';
+    html += '    <input type="email" name="email" placeholder="Email Address" /><br>';
+    html += '    <input type="submit" value="Subscribe Now" class="inlined" />';
+    html += '  </p>';
+    html += '</form>';
+    var options = this.lists[key]["start"];
+
+    var form = $(html);
+    form.attr("action", Boutique.URL + "subscribe/" + key);
+    if (options["button"]) { form.find("input[type=submit]").val(options["button"]); }
+    form.submit(function(e) {
+      e.preventDefault();
+      form.find("input[type=submit]").
+        attr("disabled", true).
+        val("Loading...");
+      if (document.domain == "localhost" &&
+          form.find("input[name=email]").val() == "example@example.com") {
+        form.parents(".boutique").removeClass("start").addClass("subscribed");
+        return;
+      }
+      $.ajax(form.attr("action"), {
+        data: form.serialize(),
+        dataType: "jsonp",
+        jsonp: "jsonp",
+        error: function() {
+          form.find("input[type=submit]").
+            attr("disabled", false).
+            val(options["button"] || "Subscribe Now");
+        },
+        success: function() {
+          form.parents(".boutique").
+            removeClass("start").
+            addClass("subscribed");
+        }
+      });
+    });
+    return form;
+  },
+  buildButton: function(key, state) {
+    var options = this.lists[key][state];
+    var button = $('<a class="boutique-button"></a>');
+    button.attr("href", options["href"]);
+    button.html(options["button"]);
+    var container = $("<p></p>");
+    container.append(button);
+    return container;
+  },
+  params: function(name) {
+    return decodeURIComponent((new RegExp('[?|&]' + name + '=' + '([^&;]+?)(&|#|;|$)').exec(location.search) || [,""])[1].replace(/\+/g, '%20')) || null;
+  }
+};