pat-maddox-sailthru 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Pat Maddox
+
+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.rdoc

@@ -0,0 +1,7 @@
+= sailthru
+
+Description goes here.
+
+== Copyright
+
+Copyright (c) 2009 Pat Maddox. See LICENSE for details.

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 1
+:patch: 1
+:major: 0

data/lib/sailthru/callback_result.rb

@@ -0,0 +1,20 @@
+module Sailthru
+  class CallbackResult
+    attr_reader :email
+
+    def initialize(options={})
+      @send_id = options["send_id"]
+      @email = options["email"]
+    end
+
+    def verified?
+      @email && response["email"] == @email
+    end
+
+    private
+    def response
+      return {} unless @send_id
+      @response ||= Sailthru.new_client.get_send(@send_id)
+    end
+  end
+end

data/lib/sailthru/delivery.rb

@@ -0,0 +1,11 @@
+module Sailthru
+  class Delivery
+    attr_reader :send_id, :email
+
+    def initialize(options={})
+      @send_id = options["send_id"]
+      @email = options["email"]
+      @options = options.clone
+    end
+  end
+end

data/lib/sailthru/mailer.rb

@@ -0,0 +1,49 @@
+module Sailthru
+  class Mailer
+    @deliveries = []
+    class << self
+      attr_reader :deliveries
+    end
+
+    def initialize
+      @replacements = { }
+      @options = { }
+    end
+
+    def deliver(client, template)
+      raise NoRecipientsSetError unless @recipients
+      result = client.send(@template || template, @recipients, @replacements, @options)
+      delivery = Delivery.new result
+      Mailer.deliveries << delivery
+      delivery
+    end
+
+    def recipients(*list)
+      @recipients = list.join(', ')
+    end
+
+    def template(name)
+      @template = name
+    end
+
+    def body(replacements)
+      @replacements.merge! replacements
+    end
+
+    def reply_to(email)
+      @options[:replyto] = email
+    end
+
+    class << self
+      def method_missing(m, *args, &block)
+        if /^deliver_(.*)$/ =~ m.to_s && instance_methods.include?($1)
+          message = new
+          message.send($1, *args, &block)
+          message.deliver Sailthru::new_client, $1
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/sailthru/test.rb

@@ -0,0 +1,7 @@
+module Sailthru
+  class FakeClient
+    def send(template, recipients, replacements, options)
+      {"send_id" => Guid.new.to_s, "email" => recipients}
+    end
+  end
+end

data/lib/sailthru/triggermailer_client.rb

@@ -0,0 +1,339 @@
+################################################################################
+#
+# Copyright (c) 2007 Sailthru, Inc.
+# All rights reserved.
+#
+# Special thanks to the iminlikewithyou.com team for the development
+# of this library.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions
+# are met:
+#
+# 1. Redistributions of source code must retain the above copyright
+#    notice, this list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright
+#    notice, this list of conditions and the following disclaimer in the
+#    documentation and/or other materials provided with the distribution.
+#
+# THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+# IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#
+################################################################################
+
+require 'net/http'
+require 'uri'
+require 'rubygems'
+require 'json'
+require 'md5'
+
+module Sailthru
+  class TriggermailClientException < Exception
+  end
+
+  class TriggermailClient
+    attr_accessor :api_uri, :api_key, :secret, :version, :last_request
+
+    # params:
+    #   api_key, String
+    #   secret, String
+    #   api_uri, String
+    #
+    # Instantiate a new client; constructor optionally takes overrides for key/secret/uri.
+    def initialize(api_key =nil, secret=nil, api_uri=nil)
+      @api_key = api_key || API_KEY
+      @secret  = secret || SECRET
+      @api_uri = api_uri || API_URI
+    end
+
+    # params:
+    #   template_name, String
+    #   email, String
+    #   replacements, Hash
+    #   options, Hash
+    #     replyto: override Reply-To header
+    #     test: send as test email (subject line will be marked, will not count towards stats)
+    # returns:
+    #   Hash, response data from server
+    def send(template_name, email, vars, options = {})
+      post = {}
+      post[:template] = template_name
+      post[:email] = email
+      post[:vars] = vars
+      post[:options] = options
+      result = self.api_post(:send, post)
+    end
+
+
+    # params:
+    #   send_id, Fixnum
+    # returns:
+    #   Hash, response data from server
+    #
+    # Get the status of a send.
+    def get_send(send_id)
+      self.api_get(:send, {:send_id => send_id.to_s})
+    end
+
+    # params:
+    #   name, String
+    #   list, String
+    #   schedule_time, String
+    #   from_name, String
+    #   from_email, String
+    #   subject, String
+    #   content_html, String
+    #   content_text, String
+    #   options, Hash
+    # returns:
+    #   Hash, response data from server
+    #
+    # Schedule a mass mail blast
+    def schedule_blast(name, list, schedule_time, from_name, from_email, subject, content_html, content_text, options)
+      post = options ? options : {}
+      post[:name] = name
+      post[:list] = list
+      post[:schedule_time] = schedule_time
+      post[:from_name] = from_name
+      post[:from_email] = from_email
+      post[:subject] = subject
+      post[:content_html] = content_html
+      post[:content_text] = content_text
+      self.api_post(:blast, post)
+    end
+
+
+    # params:
+    #   blast_id, Fixnum
+    # returns:
+    #   Hash, response data from server
+    #
+    # Get information on a previously scheduled email blast
+    def get_blast(blast_id)
+      self.api_get(:blast, {:blast_id => blast_id.to_s})
+    end
+
+    # params:
+    #   email, String
+    # returns:
+    #   Hash, response data from server
+    #
+    # Return information about an email address, including replacement vars and lists.
+    def get_email(email)
+      self.api_get(:email, {:email => email})
+    end
+
+    # params:
+    #   email, String
+    #   vars, Hash
+    #   lists, Hash mapping list name => 1 for subscribed, 0 for unsubscribed
+    # returns:
+    #   Hash, response data from server
+    #
+    # Set replacement vars and/or list subscriptions for an email address.
+    def set_email(email, vars = {}, lists = {})
+      data = {:email => email}
+      data[:vars] = vars unless vars.empty?
+      data[:lists] = lists unless lists.empty?
+      self.api_post(:email, data)
+    end
+
+    # params:
+    #  email, String
+    #  password, String
+    #  with_names, Boolean
+    # returns:
+    #  Hash, response data from server
+    #
+    # Fetch email contacts from an address book at one of the major email providers (aol/gmail/hotmail/yahoo)
+    # Use the with_names parameter if you want to fetch the contact names as well as emails
+    def import_contacts(email, password, with_names = false)
+      data = { :email => email, :password => password }
+      data[:names] = 1 if with_names
+      self.api_post(:contacts, data)
+    end
+
+
+    # params:
+    #   template_name, String
+    # returns:
+    #   Hash of response data.
+    #
+    # Get a template.
+    def get_template(template_name)
+      self.api_get(:template, {:template => template_name})
+    end
+
+
+    # params:
+    #   template_name, String
+    #   template_fields, Hash
+    # returns:
+    #   Hash containg response from the server.
+    #
+    # Save a template.
+    def save_template(template_name, template_fields)
+      data = template_fields
+      data[:template] = template_name
+      self.api_post(:template, data)
+    end
+
+
+    # params:
+    #   params, Hash
+    #   request, String
+    # returns:
+    #   TrueClass or FalseClass, Returns true if the incoming request is an authenticated verify post.
+    def receive_verify_post(params, request)
+      if request.post?
+        [:action, :email, :send_id, :sig].each { |key| return false unless params.has_key?(key) }
+
+        return false unless params[:action] == :verify
+
+        sig = params[:sig]
+        params.delete(:sig)
+        return false unless sig == TriggermailClient.get_signature_hash(params, @secret)
+
+        _send = self.get_send(params[:send_id])
+        return false unless _send.has_key?(:email)
+
+        return false unless _send[:email] == params[:email]
+
+        return true
+      else
+        return false
+      end
+    end
+
+
+    # Perform API GET request
+    def api_get(action, data)
+      api_request(action, data, 'GET')
+    end
+
+    # Perform API POST request
+    def api_post(action, data)
+      api_request(action, data, 'POST')
+    end
+
+    # params:
+    #   action, String
+    #   data, Hash
+    #   request, String "GET" or "POST"
+    # returns:
+    #   Hash
+    #
+    # Perform an API request, using the shared-secret auth hash.
+    #
+    def api_request(action, data, request_type)
+      data[:api_key] = @api_key
+      data[:format] ||= 'json'
+      data[:sig] = TriggermailClient.get_signature_hash(data, @secret)
+      _result = self.http_request("#{@api_uri}/#{action}", data, request_type)
+
+
+      # NOTE: don't do the unserialize here
+      unserialized = JSON.parse(_result)
+      return unserialized ? unserialized : _result
+    end
+
+
+    # params:
+    #   uri, String
+    #   data, Hash
+    #   method, String "GET" or "POST"
+    # returns:
+    #   String, body of response
+    def http_request(uri, data, method = 'POST')
+      data = flatten_nested_hash(data, false)
+      # puts data.inspect
+      if method == 'POST'
+        post_data = data
+      else
+        uri += "?" + data.map{ |key, value| "#{key}=#{value}" }.join("&")
+      end
+
+      req = nil
+      headers = {"User-Agent" => "Triggermail API Ruby Client #{VERSION}"}
+
+      _uri  = URI.parse(uri)
+      if method == 'POST'
+        req = Net::HTTP::Post.new(_uri.path, headers)
+        req.set_form_data(data)
+      else
+        req = Net::HTTP::Get.new("#{_uri.path}?#{_uri.query}", headers)
+      end
+
+      @last_request = req
+      begin
+        response = Net::HTTP.start(_uri.host, _uri.port) {|http|
+          http.request(req)
+        }
+      rescue Exception => e
+        raise TriggermailClientException.new("Unable to open stream: #{_uri.to_s}");
+      end
+
+      if response.body
+        return response.body
+      else
+        raise TriggermailClientException.new("No response received from stream: #{_uri.to_s}")
+      end
+
+    end
+
+    # Flatten nested hash for GET / POST request.
+    def flatten_nested_hash(hash, brackets = true)
+      f = {}
+      hash.each do |key, value|
+        _key = brackets ? "[#{key}]" : key.to_s
+        if value.class == Hash
+          flatten_nested_hash(value).each do |k, v|
+            f["#{_key}#{k}"] = v
+          end
+        else
+          f[_key] = value
+        end
+      end
+      return f
+    end
+
+    # params:
+    #   params, Hash
+    # returns:
+    #   Array, values of each item in the Hash (and nested hashes)
+    #
+    # Extracts the values of a set of parameters, recursing into nested assoc arrays.
+    def self.extract_param_values(params)
+      values = []
+      params.each do |k, v|
+        # puts "k,v: #{k}, #{v}"
+        if v.class == Hash
+          values.concat TriggermailClient.extract_param_values(v)
+        else
+          values.push v
+        end
+      end
+      return values
+    end
+
+
+    # params:
+    #   params, Hash
+    #   secret, String
+    # returns:
+    #   String, an MD5 hash of the secret + sorted list of parameter values for an API call.
+    def self.get_signature_hash(params, secret)
+      string = secret + self.extract_param_values(params).sort.join("")
+      MD5.md5(string) # debuggin
+    end
+
+  end
+end

data/lib/sailthru.rb

@@ -0,0 +1,19 @@
+require 'sailthru/triggermailer_client'
+require 'sailthru/mailer'
+require 'sailthru/delivery'
+require 'sailthru/callback_result'
+
+module Sailthru
+  API_URI = 'http://api.sailthru.com'
+  VERSION = '1.0'
+
+  class << self
+    attr_writer :mode
+
+    def new_client
+      @mode.to_s == "test" ? FakeClient.new : TriggermailClient.new
+    end
+  end
+
+  class NoRecipientsSetError < RuntimeError; end
+end

data/spec/sailthru_callback_result_spec.rb

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sailthru::CallbackResult do
+  it "should not be verified when built without a send_id" do
+    Sailthru::CallbackResult.new("email" => "foo").should_not be_verified
+  end
+
+  it "should not be verified when built without an email" do
+    Sailthru::CallbackResult.new("send_id" => "abc123").should_not be_verified
+  end
+
+  it "should expose the email" do
+    Sailthru::CallbackResult.new("email" => "foo").email.should == "foo"
+  end
+
+  describe "verified?" do
+    before(:each) do
+      @callback = Sailthru::CallbackResult.new "send_id" => "abc123", "email" => "pat@example.com"
+      @client = mock("client")
+      Sailthru.stub!(:new_client).and_return @client
+    end
+
+    it "should query the client once" do
+      @client.should_receive(:get_send).with("abc123").and_return({})
+      2.times { @callback.verified? }
+    end
+
+    it "should be true if the response contains the email" do
+      @client.stub!(:get_send).and_return({"email" => "pat@example.com"})
+      @callback.should be_verified
+    end
+
+    it "should be false if the response does not contain the email" do
+      @client.stub!(:get_send).and_return({})
+      @callback.should_not be_verified
+    end
+
+    it "should be false if the response contains a different email" do
+      @client.stub!(:get_send).and_return({"email" => "wrong@address.com"})
+      @callback.should_not be_verified
+    end
+  end
+end

data/spec/sailthru_delivery_spec.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sailthru::Delivery do
+  describe "when sent" do
+    before(:each) do
+      @delivery = MyMailer.deliver_invitation 'pat.maddox@gmail.com'
+    end
+
+    it "should be a kind of delivery" do
+      @delivery.should be_instance_of(Sailthru::Delivery)
+    end
+
+    it "should add the message to the list of deliveries" do
+      Sailthru::Mailer.deliveries.should == [@delivery]
+    end
+
+    it "should expose the send_id" do
+      @delivery.send_id.should_not be_nil
+    end
+
+    it "should expose the email" do
+      @delivery.email.should_not be_nil
+    end
+  end
+end

data/spec/sailthru_mailer_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+
+describe Sailthru::Mailer do
+  it "should create a client" do
+    Sailthru.mode = :deliver
+    Sailthru.new_client.should be_kind_of(Sailthru::TriggermailClient)
+  end
+
+  describe "mode" do
+    it "should create a client when mode is deliver" do
+      Sailthru.mode = :deliver
+      c = stub("client", :null_object => true)
+      Sailthru::TriggermailClient.should_receive(:new).and_return c
+      MyMailer.deliver_invitation 'pat.maddox@gmail.com'
+    end
+
+    it "should not create a client when mode is test" do
+      Sailthru.mode = :test
+      Sailthru::TriggermailClient.should_not_receive(:new)
+      MyMailer.deliver_invitation 'pat.maddox@gmail.com'
+    end
+  end
+
+  describe "sending an email" do
+    before(:each) do
+      @mock_client = mock('client', :send => {:send_id => "abc123"})
+      Sailthru::TriggermailClient.stub!(:new).and_return @mock_client
+      Sailthru.mode = :deliver
+    end
+
+    it "should create a client for each email sent" do
+      c = stub("client", :null_object => true)
+      Sailthru::TriggermailClient.should_receive(:new).twice.and_return c
+      2.times { MyMailer.deliver_invitation('pat@example.com') }
+    end
+
+    it "should infer the template name" do
+      @mock_client.should_receive(:send).with("invitation", anything, anything, anything)
+      MyMailer.deliver_invitation('pat@example.com')
+    end
+
+    it "should get the recipients from the mailer" do
+      @mock_client.should_receive(:send).with(anything, "pat@example.com", anything, anything)
+      MyMailer.deliver_invitation('pat@example.com')
+    end
+
+    it "should pass body options to the mailer" do
+      @mock_client.should_receive(:send).with(anything, anything, {:foo => "passed in"}, anything)
+      MyMailer.deliver_invitation('pat@example.com')
+    end
+
+    it "should pass reply-to to the mailer" do
+      @mock_client.should_receive(:send).with(anything, anything, anything, {:replyto => "admin@example.com"})
+      MyMailer.deliver_invitation('pat@example.com')
+    end
+
+    it "should allow the template to be overridden" do
+      @mock_client.should_receive(:send).with('super_template', anything, anything, anything)
+      MyMailer.deliver_with_custom_template
+    end
+
+    it "should blow up if recipients is not set" do
+      lambda { MyMailer.deliver_with_no_recipients }.
+        should raise_error(Sailthru::NoRecipientsSetError)
+    end
+
+    it "should send an empty hash if no body params are set" do
+      @mock_client.should_receive(:send).with(anything, anything, { }, anything)
+      MyMailer.deliver_with_no_body
+    end
+
+    it "should send an empty hash if reply-to is not set" do
+      @mock_client.should_receive(:send).with(anything, anything, anything, { })
+      MyMailer.deliver_with_no_reply_to
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'sailthru'
+require 'sailthru/test'
+require 'guid'
+
+Spec::Runner.configure do |config|
+  config.before(:each) do
+    Sailthru.mode = :test
+    Sailthru::Mailer.deliveries.clear
+  end
+end
+
+Sailthru::API_KEY = 'fake-api-key'
+Sailthru::SECRET = 'fake-api-secret'
+
+class MyMailer < Sailthru::Mailer
+  def invitation(email_address)
+    recipients email_address
+    body :foo => "passed in"
+    reply_to "admin@example.com"
+  end
+
+  def with_custom_template
+    template 'super_template'
+    recipients 'ignore@ignore.com'
+  end
+
+  def with_no_recipients
+    body :ignore => 'ignore'
+  end
+
+  def with_no_body
+    recipients "foo@blah.com"
+    reply_to "ignore"
+  end
+
+  def with_no_reply_to
+    recipients "foo@blah.com"
+    body :ignore => 'ignore'
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: pat-maddox-sailthru
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Pat Maddox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-09 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: 
+email: pat.maddox@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- README.rdoc
+- VERSION.yml
+- lib/sailthru
+- lib/sailthru/callback_result.rb
+- lib/sailthru/delivery.rb
+- lib/sailthru/mailer.rb
+- lib/sailthru/test.rb
+- lib/sailthru/triggermailer_client.rb
+- lib/sailthru.rb
+- spec/sailthru_callback_result_spec.rb
+- spec/sailthru_delivery_spec.rb
+- spec/sailthru_mailer_spec.rb
+- spec/spec_helper.rb
+- LICENSE
+has_rdoc: true
+homepage: http://github.com/pat-maddox/sailthru
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: TODO
+test_files: []
+