cheetah_mail 0.6.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c01f354fc476cb79988ae5509011f6754a0b785
+  data.tar.gz: e77f393ee9e419807209d78d193588119231e695
+SHA512:
+  metadata.gz: 3e84afa133084fd2d3cbc1185359e370b25a44dbcb8beed4cc6fd740c7a9c74fecb90cd4bb0b207d13b1fabb3b8a6996b3c5ecf16d34a61fe23ed1966df2c19a
+  data.tar.gz: e587c58b20dbaee3db0f95c2f99b2605ace28ece998c2b022c24441046113a5b45d9d0ab752a69bfd6a2a818d700a28a24faa8b9bae623fd55f2e498e9fd438d

data/.gitignore

@@ -0,0 +1,7 @@
+*.gem
+.bundle
+pkg/*
+*.swp
+.rvmrc
+.ruby-version
+.ruby-gemset

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--debug

data/Gemfile

@@ -0,0 +1,15 @@
+source 'http://rubygems.org'
+source "http://gems.github.com"
+
+# Specify your gem's dependencies in cheetah.gemspec
+gemspec
+
+group :development, :test do
+  gem 'ruby-debug', :platforms => :ruby_18
+	gem 'ruby-debug19', :platforms => :ruby_19
+end
+
+group :test do
+  gem 'json'
+  gem 'ZenTest'
+end

data/Gemfile.lock

@@ -0,0 +1,77 @@
+PATH
+  remote: .
+  specs:
+    cheetah_mail (0.6.0)
+      resque
+
+GEM
+  remote: http://rubygems.org/
+  remote: http://gems.github.com/
+  specs:
+    ZenTest (4.9.5)
+    archive-tar-minitar (0.5.2)
+    columnize (0.3.6)
+    diff-lcs (1.2.5)
+    fakeweb (1.3.0)
+    json (1.8.1)
+    linecache (0.46)
+      rbx-require-relative (> 0.0.4)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    mono_logger (1.1.0)
+    multi_json (1.9.0)
+    rack (1.5.2)
+    rack-protection (1.5.2)
+      rack
+    rbx-require-relative (0.0.9)
+    redis (3.0.7)
+    redis-namespace (1.4.1)
+      redis (~> 3.0.4)
+    resque (1.25.2)
+      mono_logger (~> 1.0)
+      multi_json (~> 1.0)
+      redis-namespace (~> 1.3)
+      sinatra (>= 0.9.2)
+      vegas (~> 0.1.2)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.8)
+    rspec-expectations (2.14.5)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.6)
+    ruby-debug (0.10.4)
+      columnize (>= 0.1)
+      ruby-debug-base (~> 0.10.4.0)
+    ruby-debug-base (0.10.4)
+      linecache (>= 0.3)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    sinatra (1.4.4)
+      rack (~> 1.4)
+      rack-protection (~> 1.4)
+      tilt (~> 1.3, >= 1.3.4)
+    tilt (1.4.1)
+    vegas (0.1.11)
+      rack (>= 1.0.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ZenTest
+  cheetah_mail!
+  fakeweb
+  json
+  rspec
+  ruby-debug
+  ruby-debug19

data/README.md

@@ -0,0 +1,57 @@
+CheetahMail for ruby
+====================
+
+A fork of Dan Rodriguez' original gem which interacts with the CheetahMail API. This is an attempt to make it work with newer rubies (the original only seemed to work ruby 1.8.x).
+
+To use this fork in your project, add to your Gemfile:
+
+```ruby
+gem 'cheetah_mail', git: 'https://github.com/adamtao/cheetah_mail.git'
+```
+
+Then run bundler. 
+
+
+Usage
+----------------------
+
+Basically you create a Cheetah instance like so:
+
+```ruby
+cheetah = CheetahMail::CheetahMail.new({
+  :host             => 'ebm.cheetahmail.com',
+  :username         => 'foo_api_user',
+  :password         => '12345',
+  :aid              => '67890',                  # the 'affiliate id'
+  :whitelist_filter => //,                       # if set, emails will only be sent to addresses which match this pattern
+  :enable_tracking  => true,                     # determines whether cheetahmail will track the sending of emails for analytics purposes
+  :messenger        => CheetahMail::ResqueMessenger
+})
+```
+
+Options for :messenger include CheetahMail::ResqueMessenger or CheetahMail::SynchronousMessenger .
+
+To send a message:
+```ruby
+cheetah.send_email(
+  eid,    # cheetahmail's EID for the event triggered email
+  email,
+  params, # a hash of parameters used to populate any dynamic fields in the email template
+)
+```
+
+To add or update a description:
+```ruby
+cheetah.mailing_list_update(
+  email,
+  params # a hash of parameters to populate the mailing list fields with
+)
+```
+
+Finally, update someone's email address:
+```ruby
+cheetah.mailing_list_email_change(
+  oldemail,
+  newemail
+)
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+# the following lines are so that resque workers can be run from rake within this project. mainly for testing
+require 'resque/tasks'
+task 'resque:setup' => :environment
+task :environment do
+  require 'cheetah_mail'
+end

data/cheetah_mail.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "cheetah_mail/version"
+
+Gem::Specification.new do |s|
+  s.name        = "cheetah_mail"
+  s.version     = CheetahMail::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dan Rodriguez", "Adam Anderson"]
+  s.email       = ["theoperand@gmail.com", "adam@makeascene.com"]
+  s.homepage    = ""
+  s.summary     = %q{A simple library for integrating with the CheetahMail API}
+  s.description = %q{A simple library for integrating with the CheetahMail API}
+
+  s.rubyforge_project = "cheetah_mail"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'fakeweb'
+
+  s.add_runtime_dependency 'resque'
+  # s.add_runtime_dependency 'system_timer' #only for ruby 1.8.x
+end

data/lib/cheetah_mail.rb

@@ -0,0 +1,56 @@
+require 'cheetah_mail/message'
+require 'cheetah_mail/exception'
+require 'cheetah_mail/messenger/messenger'
+Dir["#{File.dirname(__FILE__)}/cheetah_mail/messenger/*.rb"].each {|f| require f}
+
+module CheetahMail
+  class CheetahMail
+
+    UNSUB_REASON = {
+      'a'	=> 'abuse complaint',
+      'b'	=> 'persistent bounces',
+      'd'	=> 'deleted via admin interface',
+      'e'	=> 'email to remove address (from mailing)',
+      'i'	=> 'request via api',
+      'k'	=> 'bulk unsubscribe',
+      'r'	=> 'request in reply to mailing',
+      'w'	=> 'web-based unsubscribe (link from mailing)',
+    }
+
+    # options hash example (all fields are required, except whitelist_filter):
+    # {
+    #   :host             => 'ebm.cheetahmail.com'
+    #   :username         => 'foo_api_user'
+    #   :password         => '12345'
+    #   :aid              => '67890'                  # the 'affiliate id'
+    #   :whitelist_filter => //                       # if set, emails will only be sent to addresses which match this pattern
+    #   :enable_tracking  => true                     # determines whether cheetahmail will track the sending of emails for analytics purposes
+    #   :messenger        => CheetahMail::ResqueMessenger
+    # }
+    def initialize(options)
+      @messenger = options[:messenger].new(options)
+    end
+
+    def send_email(eid, email, params = {})
+      path = "/ebm/ebmtrigger1"
+      params['eid']   = eid
+      params['email'] = email
+      @messenger.send_message(Message.new(path, params))
+    end
+
+    def mailing_list_update(email, params = {})
+      path = "/api/setuser1"
+      params['email'] = email
+      @messenger.send_message(Message.new(path, params))
+    end
+
+    def mailing_list_email_change(oldemail, newemail)
+      path = "/api/setuser1"
+      params             = {}
+      params['email']    = oldemail
+      params['newemail'] = newemail
+      @messenger.send_message(Message.new(path, params))
+    end
+
+  end
+end

data/lib/cheetah_mail/exception.rb

@@ -0,0 +1,14 @@
+class CheetahMailException < Exception
+end
+
+class CheetahMailMessagingException < CheetahMailException
+end
+
+class CheetahMailAuthorizationException < CheetahMailMessagingException
+end
+
+class CheetahMailTemporaryException < CheetahMailMessagingException
+end
+
+class CheetahMailPermanentException < CheetahMailMessagingException
+end

data/lib/cheetah_mail/message.rb

@@ -0,0 +1,8 @@
+class Message
+  attr_accessor :path, :params
+
+  def initialize path, params
+    @path   = path
+    @params = params
+  end
+end

data/lib/cheetah_mail/messenger/messenger.rb

@@ -0,0 +1,76 @@
+require 'net/http'
+require 'net/https'
+require 'uri'
+
+module CheetahMail
+  class Messenger
+
+    def initialize(options)
+      @options  = options
+      @cookie   = nil
+    end
+
+    # determines if and how to send based on options
+    # returns true if the message was sent
+    # false if it was suppressed
+    def send_message(message)
+      if !@options[:whitelist_filter] or message.params['email'] =~ @options[:whitelist_filter]
+        message.params['test'] = "1" unless @options[:enable_tracking]
+        do_send(message) # implemented by the subclass
+        true
+      else
+        false
+      end
+    end
+
+    # handles sending the request and processing any exceptions
+    def do_request(message)
+      begin
+        login unless @cookie
+        initheader = {'Cookie' => @cookie || ''}
+        message.params['aid'] = @options[:aid]
+        resp = do_post(message.path, message.params, initheader)
+      rescue CheetahMailAuthorizationException => e
+        # it may be that the cookie is stale. clear it and immediately retry. 
+        # if it hits another authorization exception in the login function then it will come back as a permanent exception
+        @cookie = nil
+        retry
+      end
+    end
+
+    private #####################################################################
+
+    # actually sends the request and raises any exceptions
+    def do_post(path, params, initheader = nil)
+      http              = Net::HTTP.new(@options[:host], 443)
+      http.read_timeout = 5
+      http.use_ssl      = true
+      http.verify_mode  = OpenSSL::SSL::VERIFY_PEER
+      data              = params.to_a.map { |a| "#{a[0]}=#{a[1]}" }.join("&")
+      resp              = http.post(path, data, initheader)
+
+      raise CheetahMailTemporaryException,     "failure:'#{path}?#{data}', HTTP error: #{resp.code}"            if resp.code =~ /5../
+      raise CheetahMailPermanentException,     "failure:'#{path}?#{data}', HTTP error: #{resp.code}"            if resp.code =~ /[^2]../
+      raise CheetahMailAuthorizationException, "failure:'#{path}?#{data}', Cheetah error: #{resp.body.strip}"   if resp.body =~ /^err:auth/
+      raise CheetahMailTemporaryException,     "failure:'#{path}?#{data}', Cheetah error: #{resp.body.strip}"   if resp.body =~ /^err:internal error/
+      raise CheetahMailPermanentException,     "failure:'#{path}?#{data}', Cheetah error: #{resp.body.strip}"   if resp.body =~ /^err/
+                                                                                                            
+      resp                                                                                                  
+    end
+
+    # sets the instance @cookie variable
+    def login
+      begin
+        log_msg = "(re)logging in-----------"
+        path = "/api/login1"
+        params              = {}
+        params['name']      = @options[:username]
+        params['cleartext'] = @options[:password]
+        @cookie = do_post(path, params)['set-cookie']
+      rescue CheetahMailAuthorizationException => e
+        raise CheetahMailPermanentException, "authorization exception while logging in" # this is a permanent exception, it should not be retried
+      end
+    end
+
+  end
+end

data/lib/cheetah_mail/messenger/null_messenger.rb

@@ -0,0 +1,7 @@
+module CheetahMail
+  class NullMessenger < Messenger
+    def do_send(message)
+      # do nothing
+    end
+  end
+end

data/lib/cheetah_mail/messenger/resque_messenger.rb

@@ -0,0 +1,16 @@
+require 'resque'
+
+module CheetahMail
+  # this is both extends Messenger and implements the Resque worker interface
+  class ResqueMessenger < Messenger
+    @queue = :cheetah
+
+    def do_send(message)
+      Resque.enqueue(self.class, message, @options)
+    end
+
+    def self.perform(message, options)
+      Messenger.new(options).do_request(message)
+    end
+  end
+end

data/lib/cheetah_mail/messenger/synchronous_messenger.rb

@@ -0,0 +1,7 @@
+module CheetahMail
+  class SynchronousMessenger < Messenger
+    def do_send(message)
+      do_request(message)
+    end
+  end
+end

data/lib/cheetah_mail/version.rb

@@ -0,0 +1,3 @@
+module CheetahMail
+  VERSION = "0.6.0"
+end

data/spec/cheetah_mail_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+
+describe CheetahMail::CheetahMail do
+  before do
+    options = {
+      :host             => "foo.com",
+      :username         => "foo_user",
+      :password         => "foo",
+      :aid              => "123",
+      :whitelist_filter => /@test\.com$/,
+      :enable_tracking  => false,
+      :messenger        => CheetahMail::NullMessenger,
+    }
+    @messenger  = mock(:messenger)
+    options[:messenger].stub(:new).and_return(@messenger)
+    @cheetah    = CheetahMail::CheetahMail.new(options)
+  end
+
+  context '#send_email' do
+    it 'should send a message to the ebmtrigger api' do
+      api             = '/ebm/ebmtrigger1'
+      params          = {}
+      params['eid']   = :foo
+      params['email'] = 'foo@test.com'
+      message         = Message.new(api, params)
+      Message.should_receive(:new).with(api, params).and_return(message)
+      @messenger.should_receive(:send_message).with(message)
+      @cheetah.send_email(:foo, 'foo@test.com')
+    end
+  end
+
+  context '#mailing_list_update' do
+    before do
+      @api = '/api/setuser1'
+    end
+
+    it "should should send a message to the setuser api" do
+      params          = {}
+      params['sub']   = '123'
+      params['email'] = 'foo@test.com'
+      message = Message.new(@api, params)
+      Message.should_receive(:new).with(@api, params).and_return(message)
+      @messenger.should_receive(:send_message).with(message)
+      @cheetah.mailing_list_update('foo@test.com', params)
+    end
+  end
+
+  context '#mailing_list_email_change' do
+    before do
+      @api = '/api/setuser1'
+    end
+
+    it "should should send a message to the setuser api with the old and new emails" do
+      params             = {}
+      params['email']    = 'foo@test.com'
+      params['newemail'] = 'foo2@test.com'
+      message = Message.new(@api, params)
+      Message.should_receive(:new).with(@api, params).and_return(message)
+      @messenger.should_receive(:send_message).with(message)
+      @cheetah.mailing_list_email_change('foo@test.com', 'foo2@test.com')
+    end
+  end
+end
+

data/spec/null_messenger_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe CheetahMail::NullMessenger do
+  context "#do_send" do
+    it "should do nothing" do
+      # by using the fakeweb gem we're already ensuring that no http requests are made.
+      # calling the method and seeing that no http requests are made is good enough for me.
+      @messenger = CheetahMail::NullMessenger.new({
+        :host             => "foo.com",
+        :username         => "foo_user",
+        :password         => "foo",
+        :aid              => "123",
+        :whitelist_filter => /@test\.com$/,
+        :enable_tracking  => false,
+      })
+      @messenger.do_send(Message.new("/",{}))
+    end
+  end
+end

data/spec/resque_messenger_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'resque'
+
+describe CheetahMail::ResqueMessenger do
+  before do
+    @options = {
+      :host             => "foo.com",
+      :username         => "foo_user",
+      :password         => "foo",
+      :aid              => "123",
+      :whitelist_filter => /@test\.com$/,
+      :enable_tracking  => false,
+    }
+    @messenger = CheetahMail::ResqueMessenger.new(@options)
+    @message   = Message.new("/",{})
+  end
+
+  describe '#do_send' do
+    it 'should queue up a job in resque' do
+      Resque.should_receive(:enqueue).with(CheetahMail::ResqueMessenger, @message, @options)
+      @messenger.do_send(@message)
+    end
+  end
+
+  describe '.perform' do
+    it 'should immediately send a message to cheetah' do
+      CheetahMail::Messenger.should_receive(:new).with(@options).and_return(messenger = mock(:messenger))
+      messenger.should_receive(:do_request).with(@message)
+      CheetahMail::ResqueMessenger.perform(@message, @options)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,14 @@
+require 'cheetah_mail'
+require 'net/http'
+
+# blocks http requests and throws an exception
+require 'fakeweb'
+FakeWeb.allow_net_connect = false
+
+# use this to explicitly block http requests.
+# but only use it if you know you should.
+# don't blanket your specs with it.
+def stub_http
+  Net::HTTP.stub(:new).and_return(mock(:http).as_null_object)
+end
+

data/spec/synchronous_messenger_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+# through this class I'm also testing the base messenger class
+describe CheetahMail::SynchronousMessenger do
+  before do
+    @options = {
+      :host             => "foo.com",
+      :username         => "foo_user",
+      :password         => "foo",
+      :aid              => "123",
+      :enable_tracking  => false,
+    }
+    @messenger = CheetahMail::SynchronousMessenger.new(@options)
+    stub_http
+  end
+
+  context "#do_send" do
+    before do
+      @message   = Message.new("/",{})
+      @resp      = mock(:resp).as_null_object
+      @http      = mock(:http).as_null_object
+      @http.stub(:post).and_return(@resp)
+      Net::HTTP.stub(:new).and_return(@http)
+    end
+
+    it "should send a http post" do
+      @http.should_receive(:post)
+      @messenger.do_send(@message)
+    end
+
+    it "should raise CheetahMailPermanentException when there's an authorization problem" do
+      @resp.stub(:code).and_return('200')
+      @resp.stub(:body).and_return('err:auth')
+      lambda { @messenger.do_send(@message) }.should raise_error(CheetahMailPermanentException)
+    end
+
+    it "should raise CheetahMailPermanentException when there's a permanent error on Cheetah's end" do
+      @resp.stub(:code).and_return('400')
+      lambda { @messenger.do_send(@message) }.should raise_error(CheetahMailPermanentException)
+    end
+
+    it "should raise CheetahMailTemporaryException when there's a temporary (server) error on Cheetah's end" do
+      @resp.stub(:code).and_return('500')
+      lambda { @messenger.do_send(@message) }.should raise_error(CheetahMailTemporaryException)
+    end
+
+    it "should raise CheetahMailTemporaryException when there's a temporary error on Cheetah's end" do
+      @resp.stub(:code).and_return('200')
+      @resp.stub(:body).and_return('err:internal error')
+      lambda { @messenger.do_send(@message) }.should raise_error(CheetahMailTemporaryException)
+    end
+  end
+
+  describe '#send_message' do
+    before do
+      @params = {'email' => 'foo@test.com'}
+      @message = Message.new('/', @params)
+    end
+
+    it 'should send' do
+      @messenger.should_receive(:do_send).with(@message)
+      @messenger.send_message(@message)
+    end
+
+    context 'with a whitelist filter' do
+      before do
+        @options[:whitelist_filter] = /@test\.com$/
+        @messenger = CheetahMail::SynchronousMessenger.new(@options)
+        @message   = Message.new('/', @params)
+      end
+
+      context 'and an email that does not match the whitelist filter' do
+        before do
+          @email = 'foo@bar.com'
+        end
+
+        it "should suppress the email" do
+          @message.params['email'] = @email
+          @messenger.should_not_receive(:do_send)
+          @messenger.send_message(@message)
+        end
+      end
+
+      context 'with an email that matches the whitelist filter' do
+        before do
+          @email = 'foo@test.com'
+        end
+
+        it 'should send' do
+          @messenger.should_receive(:do_send).with(@message)
+          @messenger.send_message(@message)
+        end
+
+        context "with :enable_tracking set to true" do
+          before do
+            @options[:enable_tracking] = true
+            @messenger = CheetahMail::SynchronousMessenger.new(@options)
+          end
+
+          it 'should not set the test parameter' do
+            @message.params.should_not_receive(:[]=).with('test', '1')
+            @messenger.send_message(@message)
+          end
+        end
+
+        context "with :enable_tracking set to false" do
+          before do
+            @options[:enable_tracking] = false
+            @messenger = CheetahMail::SynchronousMessenger.new(@options)
+          end
+
+          it 'should set the test parameter' do
+            @message.params.stub(:[]=)
+            @message.params.should_receive(:[]=).with('test', '1')
+            @messenger.send_message(@message)
+          end
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: cheetah_mail
+version: !ruby/object:Gem::Version
+  version: 0.6.0
+platform: ruby
+authors:
+- Dan Rodriguez
+- Adam Anderson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple library for integrating with the CheetahMail API
+email:
+- theoperand@gmail.com
+- adam@makeascene.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- cheetah_mail.gemspec
+- lib/cheetah_mail.rb
+- lib/cheetah_mail/exception.rb
+- lib/cheetah_mail/message.rb
+- lib/cheetah_mail/messenger/messenger.rb
+- lib/cheetah_mail/messenger/null_messenger.rb
+- lib/cheetah_mail/messenger/resque_messenger.rb
+- lib/cheetah_mail/messenger/synchronous_messenger.rb
+- lib/cheetah_mail/version.rb
+- spec/cheetah_mail_spec.rb
+- spec/null_messenger_spec.rb
+- spec/resque_messenger_spec.rb
+- spec/spec_helper.rb
+- spec/synchronous_messenger_spec.rb
+homepage: ''
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cheetah_mail
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A simple library for integrating with the CheetahMail API
+test_files:
+- spec/cheetah_mail_spec.rb
+- spec/null_messenger_spec.rb
+- spec/resque_messenger_spec.rb
+- spec/spec_helper.rb
+- spec/synchronous_messenger_spec.rb