postmark 0.9.19 → 1.0.0

data/VERSION

@@ -1 +1 @@
-0.9.19
+1.0.0

data/lib/postmark.rb

@@ -1,23 +1,28 @@
 require 'net/http'
 require 'net/https'
+require 'thread' unless defined? Mutex # For Ruby 1.8.7
 
+require 'postmark/inflector'
+require 'postmark/helpers/hash_helper'
+require 'postmark/helpers/message_helper'
 require 'postmark/bounce'
+require 'postmark/inbound'
 require 'postmark/json'
 require 'postmark/http_client'
+require 'postmark/api_client'
 require 'postmark/message_extensions/shared'
-require 'postmark/message_extensions/tmail'
 require 'postmark/message_extensions/mail'
 require 'postmark/handlers/mail'
-require 'postmark/attachments_fix_for_mail'
 
 module Postmark
 
   class DeliveryError < StandardError
-    attr_accessor :error_code
+    attr_accessor :error_code, :full_response
 
-    def initialize(message = nil, error_code = nil)
+    def initialize(message = nil, error_code = nil, full_response = nil)
       super(message)
       self.error_code = error_code
+      self.full_response = full_response
     end
   end
 
@@ -41,151 +46,54 @@ module Postmark
 
   extend self
 
-  attr_accessor :host, :path_prefix, :port, :secure, :api_key, :http_open_timeout, :http_read_timeout,
-    :proxy_host, :proxy_port, :proxy_user, :proxy_pass, :max_retries, :sleep_between_retries
+  @@api_client_mutex = Mutex.new
 
-  attr_writer :response_parser_class
+  attr_accessor :secure, :api_key, :proxy_host, :proxy_port, :proxy_user,
+                :proxy_pass, :host, :port, :path_prefix,
+                :http_open_timeout, :http_read_timeout, :max_retries
+
+  attr_writer :response_parser_class, :api_client
 
   def response_parser_class
     @response_parser_class ||= defined?(ActiveSupport::JSON) ? :ActiveSupport : :Json
   end
 
-  # The port on which your Postmark server runs.
-  def port
-    @port || (secure ? 443 : 80)
-  end
-
-  # The host to connect to.
-  def host
-    @host ||= 'api.postmarkapp.com'
-  end
-
-  # The path of the listener
-  def path_prefix
-    @path_prefix ||= '/'
-  end
-
-  def http_open_timeout
-    @http_open_timeout ||= 5
-  end
-
-  def http_read_timeout
-    @http_read_timeout ||= 15
-  end
-
-  def max_retries
-    @max_retries ||= 3
-  end
-
-  def sleep_between_retries
-    @sleep_between_retries ||= 10
-  end
-
   def configure
     yield self
   end
 
-  def send_through_postmark(message) #:nodoc:
-    with_retries do
-      HttpClient.post("email", Postmark::Json.encode(convert_message_to_options_hash(message)))
-    end
-  rescue Timeout::Error
-    raise TimeoutError.new($!)
-  end
-
-  def convert_message_to_options_hash(message)
-    options = Hash.new
-    headers = extract_headers_according_to_message_format(message)
-    attachments = message.export_attachments
-
-    options["From"]        = message['from'].to_s                       if message.from
-    options["ReplyTo"]     = Array[message.reply_to].flatten.join(", ") if message.reply_to
-    options["To"]          = message['to'].to_s                         if message.to
-    options["Cc"]          = message['cc'].to_s                         if message.cc
-    options["Bcc"]         = Array[message.bcc].flatten.join(", ")      if message.bcc
-    options["Subject"]     = message.subject
-    options["Attachments"] = attachments                                unless attachments.empty?
-    options["Tag"]         = message.tag.to_s                           if message.tag
-    options["Headers"]     = headers                                    if headers.size > 0
-
-    options = options.delete_if { |k,v| v.nil? }
-
-    html = message.body_html
-    text = message.body_text
-
-    if message.multipart?
-      options["HtmlBody"] = html
-      options["TextBody"] = text
-    elsif html
-      options["HtmlBody"] = html
-    else
-      options["TextBody"] = text
-    end
-
-    options
-  end
-
-  def delivery_stats
-    HttpClient.get("deliverystats")
-  end
-
-  protected
-
-  def with_retries
-    yield
-  rescue DeliveryError, Timeout::Error
-    retries = retries ? retries + 1 : 0
-    if retries < max_retries
-      retry
-    else
-      raise
-    end
-  end
-
-  def extract_headers_according_to_message_format(message)
-    if defined?(TMail) && message.is_a?(TMail::Mail)
-      headers = extract_tmail_headers(message)
-    elsif defined?(Mail) && message.kind_of?(Mail::Message)
-      headers = extract_mail_headers(message)
-    else
-      raise "Can't convert message to a valid hash of API options. Unknown message format."
+  def api_client
+    return @api_client if @api_client
+
+    @@api_client_mutex.synchronize do
+      @api_client ||= Postmark::ApiClient.new(
+                        self.api_key,
+                        :secure => self.secure,
+                        :proxy_host => self.proxy_host,
+                        :proxy_port => self.proxy_port,
+                        :proxy_user => self.proxy_user,
+                        :proxy_pass => self.proxy_pass,
+                        :host => self.host,
+                        :port => self.port,
+                        :path_prefix => self.path_prefix,
+                        :max_retries => self.max_retries
+                      )
     end
   end
 
-  def extract_mail_headers(message)
-    headers = []
-    message.header.fields.each do |field|
-      key = field.name
-      value = field.value
-      next if bogus_headers.include? key.downcase
-      name = key.split(/-/).map {|i| i.capitalize }.join('-')
-      headers << { "Name" => name, "Value" => value }
-    end
-    headers
+  def deliver_message(*args)
+    api_client.deliver_message(*args)
   end
+  alias_method :send_through_postmark, :deliver_message
 
-  def extract_tmail_headers(message)
-    headers = []
-    message.each_header do |key, value|
-      next if bogus_headers.include? key.downcase
-      name = key.split(/-/).map {|i| i.capitalize }.join('-')
-      headers << { "Name" => name, "Value" => value.body }
-    end
-    headers
+  def deliver_messages(*args)
+    api_client.deliver_messages(*args)
   end
 
-  def bogus_headers
-    %q[
-      return-path  x-pm-rcpt
-      from         reply-to
-      sender       received
-      date         content-type
-      cc           bcc
-      subject      tag
-      attachment
-    ]
+  def delivery_stats(*args)
+    api_client.delivery_stats(*args)
   end
 
-  self.response_parser_class = nil
-
 end
+
+Postmark.response_parser_class = nil

data/lib/postmark/api_client.rb

@@ -0,0 +1,162 @@
+module Postmark
+  class ApiClient
+    attr_reader :http_client, :max_retries
+    attr_writer :max_batch_size
+
+    def initialize(api_key, options = {})
+      @max_retries = options.delete(:max_retries) || 3
+      @http_client = HttpClient.new(api_key, options)
+    end
+
+    def api_key=(api_key)
+      http_client.api_key = api_key
+    end
+
+    def deliver(message_hash = {})
+      data = serialize(MessageHelper.to_postmark(message_hash))
+
+      with_retries do
+        format_response http_client.post("email", data)
+      end
+    end
+
+    def deliver_in_batches(message_hashes)
+      in_batches(message_hashes) do |batch, offset|
+        data = serialize(batch.map { |h| MessageHelper.to_postmark(h) })
+
+        with_retries do
+          http_client.post("email/batch", data)
+        end
+      end
+    end
+
+    def deliver_message(message)
+      data = serialize(message.to_postmark_hash)
+
+      with_retries do
+        take_response_of { http_client.post("email", data) }.to do |response|
+          update_message(message, response)
+          format_response response, true
+        end
+      end
+    end
+
+    def deliver_messages(messages)
+      in_batches(messages) do |batch, offset|
+        data = serialize(batch.map { |m| m.to_postmark_hash })
+
+        with_retries do
+          http_client.post("email/batch", data).tap do |response|
+            response.each_with_index do |r, i|
+              update_message(messages[offset + i], r)
+            end
+          end
+        end
+      end
+    end
+
+    def delivery_stats
+      response = format_response(http_client.get("deliverystats"), true)
+
+      if response[:bounces]
+        response[:bounces] = format_response(response[:bounces])
+      end
+
+      response
+    end
+
+    def get_bounces(options = {})
+      format_response http_client.get("bounces", options)["Bounces"]
+    end
+
+    def get_bounced_tags
+      http_client.get("bounces/tags")
+    end
+
+    def get_bounce(id)
+      format_response http_client.get("bounces/#{id}")
+    end
+
+    def dump_bounce(id)
+      format_response http_client.get("bounces/#{id}/dump")
+    end
+
+    def activate_bounce(id)
+      format_response http_client.put("bounces/#{id}/activate")["Bounce"]
+    end
+
+    def server_info
+      format_response http_client.get("server")
+    end
+
+    def update_server_info(attributes = {})
+      data = HashHelper.to_postmark(attributes)
+      format_response http_client.post("server", serialize(data))
+    end
+
+    def max_batch_size
+      @max_batch_size ||= 500
+    end
+
+    protected
+
+    def with_retries
+      yield
+    rescue DeliveryError
+      retries = retries ? retries + 1 : 1
+      if retries < self.max_retries
+        retry
+      else
+        raise
+      end
+    end
+
+    def in_batches(messages)
+      r = messages.each_slice(max_batch_size).each_with_index.map do |batch, i|
+        yield batch, i * max_batch_size
+      end
+
+      format_response r.flatten
+    end
+
+    def update_message(message, response)
+      response ||= {}
+      message['Message-ID'] = response['MessageID']
+      message.delivered = !!response['MessageID']
+      message.postmark_response = response
+    end
+
+    def serialize(data)
+      Postmark::Json.encode(data)
+    end
+
+    def take_response_of
+      define_singleton_method(:to, yield)
+    rescue DeliveryError => e
+      define_singleton_method(:to, e.full_response || {}) do
+        raise e
+      end
+    end
+
+    def define_singleton_method(name, object)
+      singleton_class = class << object; self; end
+      singleton_class.send(:define_method, name) do |&b|
+        ret = b.call(self) if b
+        yield if block_given?
+        ret
+      end
+      object
+    end
+
+    def format_response(response, compatible = false)
+      return {} unless response
+
+      if response.kind_of? Array
+        response.map { |entry| Postmark::HashHelper.to_ruby(entry, compatible) }
+      else
+        Postmark::HashHelper.to_ruby(response, compatible)
+      end
+    end
+
+  end
+end

data/lib/postmark/bounce.rb

@@ -6,18 +6,19 @@ module Postmark
     attr_reader :email, :bounced_at, :type, :details, :name, :id, :server_id, :tag, :message_id, :subject
 
     def initialize(values = {})
-      @id             = values["ID"]
-      @email          = values["Email"]
-      @bounced_at     = Time.parse(values["BouncedAt"])
-      @type           = values["Type"]
-      @name           = values["Name"]
-      @details        = values["Details"]
-      @tag            = values["Tag"]
-      @dump_available = values["DumpAvailable"]
-      @inactive       = values["Inactive"]
-      @can_activate   = values["CanActivate"]
-      @message_id     = values["MessageID"]
-      @subject        = values["Subject"]
+      values = Postmark::HashHelper.to_ruby(values)
+      @id = values[:id]
+      @email = values[:email]
+      @bounced_at = Time.parse(values[:bounced_at])
+      @type = values[:type]
+      @name = values[:name]
+      @details = values[:details]
+      @tag = values[:tag]
+      @dump_available = values[:dump_available]
+      @inactive = values[:inactive]
+      @can_activate = values[:can_activate]
+      @message_id = values[:message_id]
+      @subject = values[:subject]
     end
 
     def inactive?
@@ -29,11 +30,11 @@ module Postmark
     end
 
     def dump
-      Postmark::HttpClient.get("bounces/#{id}/dump")["Body"]
+      Postmark.api_client.dump_bounce(id)[:body]
     end
 
     def activate
-      Bounce.new(Postmark::HttpClient.put("bounces/#{id}/activate")["Bounce"])
+      Bounce.new(Postmark.api_client.activate_bounce(id))
     end
 
     def dump_available?
@@ -42,17 +43,19 @@ module Postmark
 
     class << self
       def find(id)
-        Bounce.new(Postmark::HttpClient.get("bounces/#{id}"))
+        Bounce.new(Postmark.api_client.get_bounce(id))
       end
 
       def all(options = {})
         options[:count]  ||= 30
         options[:offset] ||= 0
-        Postmark::HttpClient.get("bounces", options)['Bounces'].map { |bounce_json| Bounce.new(bounce_json) }
+        Postmark.api_client.get_bounces(options).map do |bounce_json|
+          Bounce.new(bounce_json)
+        end
       end
 
       def tags
-        Postmark::HttpClient.get("bounces/tags")
+        Postmark.api_client.get_bounced_tags
       end
     end
 

data/lib/postmark/handlers/mail.rb

@@ -8,9 +8,16 @@ module Mail
     end
 
     def deliver!(mail)
-      ::Postmark.api_key = settings[:api_key]
-      response = ::Postmark.send_through_postmark(mail)
-      mail["Message-ID"] = response["MessageID"] if response.kind_of?(Hash)
+      settings = self.settings.dup
+      api_key = settings.delete(:api_key)
+      api_client = ::Postmark::ApiClient.new(api_key, settings)
+      response = api_client.deliver_message(mail)
+
+      if settings[:return_response]
+        response
+      else
+        self
+      end
     end
 
   end