postmark 0.9.10 → 0.9.11

data/.bundle/config

@@ -1,3 +1,2 @@
---- 
-BUNDLE_WITHOUT: ""
-BUNDLE_DISABLE_SHARED_GEMS: "1"
+---
+BUNDLE_WITHOUT: ''

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--format documentation

data/CHANGELOG.rdoc

@@ -1,5 +1,12 @@
 = Changelog
 
+== 0.9.11
+
+* Replaced Jeweler by Bundler
+* Updated RSpec to 2.8
+* Fixed specs
+* Refactored the codebase
+
 == 0.9.10
 
 * Fixed Ruby 1.9 compatibility issue

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in postmark.gemspec
+gemspec
+
+
+group :development do
+
+end
+
+

data/README.rdoc

@@ -114,7 +114,10 @@ You can also explicitly specify which one to be used, using
 * Chris Williams
 * Aitor García Rey
 * James Miller
+* Yury Batenko
+* Pavel Maksimenko
+* Anton Astashov
 
 == Copyright
 
-Copyright (c) 2011 Wildbit LLC. See LICENSE for details.
+Copyright (c) 2012 Wildbit LLC. See LICENSE for details.

data/Rakefile

@@ -1,63 +1,3 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name        = "postmark"
-    gem.summary     = %Q{Official Postmark API wrapper.}
-    gem.description = %Q{Use this gem to send emails through Postmark HTTP API and retrieve info about bounces.}
-    gem.email       = "ilya@wildbit.com"
-    gem.homepage    = "http://postmarkapp.com"
-    gem.authors     = ["Petyo Ivanov", "Ilya Sabanin", "Artem Chistyakov"]
-
-    gem.add_development_dependency "rspec"
-    gem.add_development_dependency "activesupport"
-    gem.add_development_dependency "json"
-    gem.add_development_dependency "ruby-debug"
-    gem.add_development_dependency "fakeweb"
-    gem.add_development_dependency "fakeweb-matcher"
-    gem.add_development_dependency "timecop"
-    gem.add_development_dependency "yajl-ruby"
-
-    gem.post_install_message = %q[
-      ==================
-      Thanks for installing the postmark gem. If you don't have an account, please sign up at http://postmarkapp.com/.
-      Review the README.rdoc for implementation details and examples.
-      ==================
-    ]
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
-end
-
-require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new(:spec) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-Spec::Rake::SpecTask.new(:rcov) do |spec|
-  spec.libs << 'lib' << 'spec'
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rcov = true
-end
-
-task :spec => :check_dependencies
-
-task :default => :spec
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  if File.exist?('VERSION')
-    version = File.read('VERSION')
-  else
-    version = ""
-  end
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "postmark #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/VERSION

@@ -1 +1 @@
-0.9.10
+0.9.11

data/lib/postmark.rb

@@ -36,148 +36,149 @@ module Postmark
 
   MAX_RETRIES = 2
 
-  class << 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
+  extend self
 
-    attr_writer :response_parser_class
+  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
 
-    def response_parser_class
-      @response_parser_class ||= Object.const_defined?(:ActiveSupport) ? :ActiveSupport : :Json
-    end
+  attr_writer :response_parser_class
 
-    # The port on which your Postmark server runs.
-    def port
-      @port || (secure ? 443 : 80)
-    end
+  def response_parser_class
+    @response_parser_class ||= Object.const_defined?(:ActiveSupport) ? :ActiveSupport : :Json
+  end
 
-    # The host to connect to.
-    def host
-      @host ||= 'api.postmarkapp.com'
-    end
+  # The port on which your Postmark server runs.
+  def port
+    @port || (secure ? 443 : 80)
+  end
 
-    # The path of the listener
-    def path_prefix
-      @path_prefix ||= '/'
-    end
+  # The host to connect to.
+  def host
+    @host ||= 'api.postmarkapp.com'
+  end
 
-    def http_open_timeout
-      @http_open_timeout ||= 5
-    end
+  # The path of the listener
+  def path_prefix
+    @path_prefix ||= '/'
+  end
 
-    def http_read_timeout
-      @http_read_timeout ||= 15
-    end
+  def http_open_timeout
+    @http_open_timeout ||= 5
+  end
 
-    def max_retries
-      @max_retries ||= 3
-    end
+  def http_read_timeout
+    @http_read_timeout ||= 15
+  end
 
-    def sleep_between_retries
-      @sleep_between_retries ||= 10
-    end
+  def max_retries
+    @max_retries ||= 3
+  end
 
-    def configure
-      yield self
-    end
+  def sleep_between_retries
+    @sleep_between_retries ||= 10
+  end
 
-    def send_through_postmark(message) #:nodoc:
-      @retries = 0
-      begin
-        HttpClient.post("email", Postmark::Json.encode(convert_message_to_options_hash(message)))
-      rescue DeliveryError => e
-        if @retries < max_retries
-           @retries += 1
-           retry
-        else
-          raise
-        end
-      end
-    end
+  def configure
+    yield self
+  end
 
-    def convert_message_to_options_hash(message)
-      options = Hash.new
-      headers = extract_headers_according_to_message_format(message)
-
-      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"] = message.postmark_attachments
-      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
+  def send_through_postmark(message) #:nodoc:
+    @retries = 0
+    begin
+      HttpClient.post("email", Postmark::Json.encode(convert_message_to_options_hash(message)))
+    rescue DeliveryError => e
+      if @retries < max_retries
+         @retries += 1
+         retry
       else
-        options["TextBody"] = text
+        raise
       end
-
-      options
     end
+  end
 
-    def delivery_stats
-      HttpClient.get("deliverystats")
-    end
+  def convert_message_to_options_hash(message)
+    options = Hash.new
+    headers = extract_headers_according_to_message_format(message)
 
-  protected
+    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"] = message.postmark_attachments
+    options["Tag"]         = message.tag.to_s                           if message.tag
+    options["Headers"]     = headers                                    if headers.size > 0
 
-    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."
-      end
+    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
 
-    def extract_mail_headers(message)
-      headers = []
-      message.header.fields.each do |field|
-        key = field.name
-        value = field.value
-        next if bogus_headers.include? key.dup.downcase
-        name = key.split(/-/).map {|i| i.capitalize }.join('-')
-        headers << { "Name" => name, "Value" => value }
-      end
-      headers
+    options
+  end
+
+  def delivery_stats
+    HttpClient.get("deliverystats")
+  end
+
+  protected
+
+  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."
     end
+  end
 
-    def extract_tmail_headers(message)
-      headers = []
-      message.each_header do |key, value|
-        next if bogus_headers.include? key.dup.downcase
-        name = key.split(/-/).map {|i| i.capitalize }.join('-')
-        headers << { "Name" => name, "Value" => value.body }
-      end
-      headers
+  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
+  end
 
-    def bogus_headers
-      %q[
-        return-path  x-pm-rcpt
-        from         reply-to
-        sender       received
-        date         content-type
-        cc           bcc
-        subject      tag
-        attachment
-      ]
+  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
+  end
 
+  def bogus_headers
+    %q[
+      return-path  x-pm-rcpt
+      from         reply-to
+      sender       received
+      date         content-type
+      cc           bcc
+      subject      tag
+      attachment
+    ]
   end
 
+
+
   self.response_parser_class = nil
 
 end

data/lib/postmark/http_client.rb

@@ -2,76 +2,75 @@ require 'cgi'
 
 module Postmark
   module HttpClient
-    class << self
-      def post(path, data = '')
-        handle_response(http.post(url_path(path), data, headers))
-      end
+    extend self
+    def post(path, data = '')
+      handle_response(http.post(url_path(path), data, headers))
+    end
 
-      def put(path, data = '')
-        handle_response(http.put(url_path(path), data, headers))
-      end
+    def put(path, data = '')
+      handle_response(http.put(url_path(path), data, headers))
+    end
 
-      def get(path, query = {})
-        handle_response(http.get(url_path(path + to_query_string(query)), headers))
-      end
+    def get(path, query = {})
+      handle_response(http.get(url_path(path + to_query_string(query)), headers))
+    end
 
-      protected
+    protected
 
-      def to_query_string(hash)
-        return "" if hash.empty?
-        "?" + hash.map { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
-      end
+    def to_query_string(hash)
+      return "" if hash.empty?
+      "?" + hash.map { |key, value| "#{CGI.escape(key.to_s)}=#{CGI.escape(value.to_s)}" }.join("&")
+    end
 
-      def protocol
-        Postmark.secure ? "https" : "http"
-      end
+    def protocol
+      Postmark.secure ? "https" : "http"
+    end
 
-      def url
-        URI.parse("#{protocol}://#{Postmark.host}:#{Postmark.port}/")
-      end
+    def url
+      URI.parse("#{protocol}://#{Postmark.host}:#{Postmark.port}/")
+    end
 
-      def handle_response(response)
-        case response.code.to_i
-        when 200
-          return Postmark::Json.decode(response.body)
-        when 401
-          raise InvalidApiKeyError, error_message(response.body)
-        when 422
-          raise InvalidMessageError, error_message(response.body)
-        when 500
-          raise InternalServerError, response.body
-        else
-          raise UnknownError, response
-        end
+    def handle_response(response)
+      case response.code.to_i
+      when 200
+        return Postmark::Json.decode(response.body)
+      when 401
+        raise InvalidApiKeyError, error_message(response.body)
+      when 422
+        raise InvalidMessageError, error_message(response.body)
+      when 500
+        raise InternalServerError, response.body
+      else
+        raise UnknownError, response
       end
+    end
 
-      def headers
-        @headers ||= HEADERS.merge({ "X-Postmark-Server-Token" => Postmark.api_key.to_s })
-      end
+    def headers
+      @headers ||= HEADERS.merge({ "X-Postmark-Server-Token" => Postmark.api_key.to_s })
+    end
 
-      def url_path(path)
-        Postmark.path_prefix + path
-      end
+    def url_path(path)
+      Postmark.path_prefix + path
+    end
 
-      def http
-        @http ||= build_http
-      end
+    def http
+      @http ||= build_http
+    end
 
-      def build_http
-        http = Net::HTTP::Proxy(Postmark.proxy_host,
-                                Postmark.proxy_port,
-                                Postmark.proxy_user,
-                                Postmark.proxy_pass).new(url.host, url.port)
+    def build_http
+      http = Net::HTTP::Proxy(Postmark.proxy_host,
+                              Postmark.proxy_port,
+                              Postmark.proxy_user,
+                              Postmark.proxy_pass).new(url.host, url.port)
 
-        http.read_timeout = Postmark.http_read_timeout
-        http.open_timeout = Postmark.http_open_timeout
-        http.use_ssl = !!Postmark.secure
-        http
-      end
+      http.read_timeout = Postmark.http_read_timeout
+      http.open_timeout = Postmark.http_open_timeout
+      http.use_ssl = !!Postmark.secure
+      http
+    end
 
-      def error_message(response_body)
-        Postmark::Json.decode(response_body)["Message"]
-      end
+    def error_message(response_body)
+      Postmark::Json.decode(response_body)["Message"]
     end
   end
 end