postful 0.1.0

data/lib/postful.rb

@@ -0,0 +1,3 @@
+require 'postful/base'
+require 'postful/letter'
+require 'postful/service'

data/lib/postful/base.rb

@@ -0,0 +1,163 @@
+require 'builder'
+require File.join(File.dirname(__FILE__), 'order')
+require File.join(File.dirname(__FILE__), 'util')
+
+module Postful #:nodoc:
+  class AuthorizationException < StandardError; end
+  class ValidationException < StandardError; end
+  class UnknownResponseException < StandardError; end    
+  class NotFoundException < StandardError; end    
+  class InternalServerError < StandardError; end
+  
+  #--
+  # TODO: address validations and SimpleValidation
+  #++
+  class Base
+    attr_accessor :tag1
+    attr_accessor :tag2
+    attr_accessor :tag3
+    attr_accessor :return_address
+    
+    include Util
+    
+    def initialize(email, password)
+      @email = email
+      @password = password
+      @documents = []      
+      @addressees = []
+    end
+
+    # Add a domestic recipient to a mailing      
+    def add_address(attributes = {})
+      returning DomesticAddress.new do |address|
+        [:name, :company, :address, :address2, :city, :state, :postal_code].each do |field|
+          address.send("#{field}=", attributes[field] || attributes[field.to_s])          
+        end
+        @addressees << address        
+      end
+    end
+
+    # Add an international recipient to a mailing      
+    def add_international_address(lines, country)
+      returning InternationalAddress.new do |address|
+        address.lines = lines
+        address.country = country
+        @addressees << address
+      end
+    end
+    
+    def mail!
+      if !valid?
+        raise errors.join("\n")
+      else
+        mail_without_validation!
+      end
+    end
+
+    def valid?
+      errors.clear
+      validate
+      errors.empty?
+    end  
+
+    def errors
+      @errors ||= []
+    end
+    
+    protected
+
+    def build_request #:nodoc:
+      request = ''
+      xml = Builder::XmlMarkup.new(:target => request)
+      xml.mail do
+        xml.documents do
+          @documents.each do |document|
+            document.build_request(xml)
+          end
+        end
+        xml.addressees do 
+          @addressees.each do |addressee|
+            addressee.build_request(xml)
+          end
+        end
+        xml.tag1 tag1 if tag1
+        xml.tag2 tag2 if tag2
+        xml.tag3 tag3 if tag3        
+        if return_address
+          xml.return_address do
+            return_address.each_with_index do |line, i|
+              xml.tag! "line#{i + 1}", line
+            end
+          end
+        end
+      end
+      request      
+    end
+    
+    def validate #:nodoc:
+      errors << 'Requires at least one addressee' if @addressees.empty?
+    end
+
+    def mail_without_validation! #:nodoc:
+      upload_documents
+      xml = build_request
+      send_request(xml)
+    end
+
+    def send_request(xml) #:nodoc:
+      response = post_request_on_path('/service/mail', xml, @email, @password)      
+      case response.code
+        when "201" then
+          Postful::Order.build_from_response(response.body, @email, @password)
+        when "422" then
+          raise Postful::ValidationException, build_error_message_from_response(response.body)
+        else
+          process_standard_responses(response)
+      end
+    end
+        
+    private
+
+    class DomesticAddress #:nodoc:
+      attr_accessor :name      
+      attr_accessor :company
+      attr_accessor :address
+      attr_accessor :address2
+      attr_accessor :city
+      attr_accessor :state
+      attr_accessor :postal_code
+
+      def build_request(builder)
+        builder.addressee do 
+          builder.name name
+          builder.company company if company
+          builder.address address
+          builder.address2 address2 if address2
+          builder.city city
+          builder.state state
+          builder.postal_code postal_code
+        end
+      end    
+    end
+    
+    class InternationalAddress #:nodoc:
+      attr_accessor :country
+      attr_accessor :lines
+      
+      def build_request(builder)
+        builder.addressee do 
+          lines.each_with_index do |line, i|
+            builder.tag! "line#{i + 1}", line
+          end          
+          builder.country country
+        end
+      end
+    end
+    
+    def returning(value)
+      yield(value)
+      value
+    end
+    
+  end  
+end

data/lib/postful/instance_exec_module.rb

@@ -0,0 +1,25 @@
+module InstanceExecModule #:nodoc:
+  unless defined? instance_exec # 1.9
+    module InstanceExecMethods #:nodoc:
+    end
+    include InstanceExecMethods
+    
+    # From Mauricio's http://eigenclass.org/hiki/bounded+space+instance_exec
+    def instance_exec(*args, &block)
+      begin
+        old_critical, Thread.critical = Thread.critical, true
+        n = 0
+        n += 1 while respond_to?(method_name = "__instance_exec#{n}")
+        InstanceExecMethods.module_eval { define_method(method_name, &block) }
+      ensure
+        Thread.critical = old_critical
+      end
+      
+      begin
+        send(method_name, *args)
+      ensure
+        InstanceExecMethods.module_eval { remove_method(method_name) } rescue nil
+      end
+    end
+  end
+end

data/lib/postful/letter.rb

@@ -0,0 +1,134 @@
+require 'net/https'
+require 'builder'
+require File.join(File.dirname(__FILE__), 'base')
+require File.join(File.dirname(__FILE__), 'util')
+
+module Postful
+  # Builder for mailing letters with the Postful Web Service.
+
+  class Letter < Base    
+    # Add an HTML document to the request
+    def add_html_document(text)
+      add_document('html', text)
+    end
+    
+    # Add an HTML document to the request
+    def add_html_document_from_file(filename)
+      add_document_from_file('html', filename)
+    end    
+
+    # Add a Microsoft Word document to the request
+    def add_word_document(text)
+      add_document('doc', text)
+    end
+
+    # Add a Microsoft Word document to the request
+    def add_word_document_from_file(filename)
+      add_document_from_file('doc', filename)
+    end
+
+    # Add a Rich Text Format document to the request
+    def add_rtf_document(text)
+      add_document('rtf', text)
+    end
+
+    # Add a Rich Text Format document to the request
+    def add_rtf_document_from_file(filename)
+      add_document_from_file('rtf', filename)
+    end
+
+    # Add an Open Office document to the request
+    def add_open_office_document(text)
+      add_document('odt', text)
+    end
+
+    # Add an Open Office document to the request
+    def add_open_office_document_from_file(filename)
+      add_document_from_file('odt', filename)
+    end
+
+    # Add a text document to the request
+    def add_text_document(text)
+      add_document('txt', text)
+    end
+
+    # Add a text document to the request
+    def add_text_document_from_file(filename)
+      add_document_from_file('txt', filename)
+    end
+
+    # Add a PDF document to the request
+    def add_pdf_document(text)
+      add_document('pdf', text)
+    end
+
+    # Add a PDF document to the request
+    def add_pdf_document_from_file(filename)
+      add_document_from_file('pdf', filename)
+    end
+
+    protected
+
+    def validate #:nodoc:
+      super
+      errors << 'Requires at least one document' if @documents.empty?
+    end    
+    
+    private
+    
+    def upload_documents
+      @documents.each do |document|
+        document.upload
+      end
+    end
+
+    def add_document(format, content)
+      returning Document.new(@email, @password) do |document|
+        document.format = format
+        document.content = content
+        @documents << document
+      end      
+    end
+
+    def add_document_from_file(format, filename)    
+      content = open(filename, "rb") do |io| 
+        io.read
+      end         
+      add_document(format, content)
+    end
+    
+    class Document #:nodoc:
+      include Util
+  
+      attr_accessor :format
+      attr_accessor :content
+      attr_accessor :attachment_name
+
+      def initialize(email, password)
+        @email = email
+        @password = password
+      end      
+      
+      def build_request(builder)
+        builder.document do
+          builder.type format
+          builder.attachment attachment_name
+        end
+      end
+      
+      def upload
+        headers = { 
+          'Content-Type' => 'application/octet-stream',
+          'Content-Length' => content.size.to_s
+          }              
+        response = post_request_on_path('/service/upload', content, @email, @password, headers)
+        if response.is_a?(Net::HTTPOK) && response.body =~ /<id>(.*)<\/id>/        
+          self.attachment_name = $1 
+        else
+          # raise stuff
+        end
+      end     
+    end
+    
+  end
+end

data/lib/postful/order.rb

@@ -0,0 +1,130 @@
+require 'rexml/document'
+require 'open-uri'
+require 'date'
+require File.join(File.dirname(__FILE__), 'instance_exec_module')
+require File.join(File.dirname(__FILE__), 'util')
+
+module Postful
+  # Represent a Postful order.
+  class Order
+    attr :id
+    attr :status
+    attr :source
+    attr :pages
+    attr :preview_url
+    attr :price    
+    attr :tag1    
+    attr :tag2
+    attr :tag3
+    attr :history
+    attr :addressees    
+    attr :warnings
+    attr :return_address
+    attr :errors
+    
+    include Util
+    
+    def preview    
+      url = URI.parse(preview_url)
+      url.read
+    end
+    
+    def refresh
+      response = get_request_on_path("/service/mail/#{id}", @email, @password)
+      case response.code
+        when "200" then
+          build_from_response(response.body)
+        else
+          process_standard_responses(response)
+      end                 
+    end
+    
+    def cancel
+      response = delete_request_on_path("/service/mail/#{id}", @email, @password)
+      case response.code
+        when "200" then
+          build_from_response(response.body)
+        when "422" then
+          raise Postful::ValidationException, build_error_message_from_response(response.body)          
+        else
+          process_standard_responses(response)
+      end                 
+    end
+    
+    private 
+    
+    def self.build_all_from_response(response, email, password)
+
+      document = REXML::Document.new response
+      root = document.root
+      results = []
+      root.elements.each("mail") do |mail|
+       results << new do
+        @email = email
+        @password = password
+        build_from_root(mail)         
+       end
+      end
+      results
+    end
+    
+    def build_from_root(root)
+      @id = root.elements['id'].text.to_i      
+      @status = root.elements['status'].text              
+      @source = root.elements['source'].text
+      @pages = root.elements['pages'].text.to_i
+      @preview_url = root.elements['preview'].text
+      @price = root.elements['price'].text        
+      @tag1 = root.elements['tag1'].text
+      @tag2 = root.elements['tag2'].text
+      @tag3 = root.elements['tag3'].text
+      @history = []
+      root.elements.each("history/status") do |element| 
+        status = []
+        status << Time.parse(element.elements['at'].text)
+        status << element.elements['message'].text
+        @history << status
+      end
+      @warnings = []        
+      root.elements.each("warnings/warning") do |element| 
+        @warnings << element.elements['message'].text
+      end
+      @return_address = []
+      root.elements["return-address"].elements.each do |element| 
+        @return_address << element.text
+      end
+      @addressees = []
+      root.elements["addressees"].elements.each do |addressee| 
+        address = []
+        addressee.elements.each do |line|
+          address << line.text
+        end
+        @addressees << address
+      end
+      @errors = []
+      root.elements.each("fatal-errors/fatal-error") do |element| 
+        @errors << element.elements['message'].text
+      end
+      self      
+    end
+    
+    def build_from_response(response)
+      document = REXML::Document.new response
+      build_from_root(document.root)
+    end
+
+    def initialize(&initializer)
+      instance_exec &initializer
+    end
+    
+    def self.build_from_response(response, email, password)
+      o = new do
+        @email = email
+        @password = password
+        build_from_response(response)
+      end
+    end
+    
+    include InstanceExecModule    
+  end
+end