postmaster 1.0.0

data/lib/postmaster/errors/postmaster_error.rb

@@ -0,0 +1,20 @@
+module Postmaster
+  class PostmasterError < StandardError
+    attr_reader :message
+    attr_reader :http_status
+    attr_reader :http_body
+    attr_reader :json_body
+
+    def initialize(message=nil, http_status=nil, http_body=nil, json_body=nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @json_body = json_body
+    end
+
+    def to_s
+      status_string = @http_status.nil? ? "" : "(Status #{@http_status}) "
+      "#{status_string}#{@message}"
+    end
+  end
+end

data/lib/postmaster/json.rb

@@ -0,0 +1,21 @@
+module Postmaster
+  module JSON
+    if MultiJson.respond_to?(:dump)
+      def self.dump(*args)
+        MultiJson.dump(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.load(*args)
+      end
+    else
+      def self.dump(*args)
+        MultiJson.encode(*args)
+      end
+
+      def self.load(*args)
+        MultiJson.decode(*args)
+      end
+    end
+  end
+end

data/lib/postmaster/package.rb

@@ -0,0 +1,6 @@
+module Postmaster
+
+  class Package < APIResource
+  end
+
+end

data/lib/postmaster/postmaster_object.rb

@@ -0,0 +1,172 @@
+module Postmaster
+  class PostmasterObject
+    include Enumerable
+   
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    def initialize(id=nil)
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      self.id = id if id
+    end
+
+    def self.construct_from(values)
+      obj = self.new(values[:id])
+      obj.refresh_from(values)
+      obj
+    end
+
+    def to_s(*args)
+      Postmaster::JSON.dump(@values, :pretty => true)
+    end
+
+    def inspect()
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + Postmaster::JSON.dump(@values, :pretty => true)
+    end
+
+    def refresh_from(values)
+      # which keys should be converted to Postmaster_Objects
+      obj_keys = {
+        'Postmaster::Shipment.to' => Postmaster::Address,
+        'Postmaster::Shipment.from_' => Postmaster::Address,
+        'Postmaster::Shipment.package' => Postmaster::Package,
+        'Postmaster::AddressProposal.address' => Postmaster::Address,
+        #'Postmaster::Tracking.last_update' => 'DateTime',
+        #'Postmaster::TrackingHistory.timestamp' => 'DateTime'
+      }
+  
+      # which keys should be converted to list of Postmaster_Objects
+      obj_list_keys = {
+        'Postmaster::AddressValidation.addresses' => Postmaster::Address,
+        'Postmaster::Shipment.packages' => Postmaster::Package,
+        'Postmaster::Tracking.history' => Postmaster::TrackingHistory
+      }
+        
+      removed = Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+      end
+      values.each do |k, v|
+        full_key = self.class.name + "." + k.to_s
+        if obj_keys.has_key?(full_key)
+          klass = obj_keys[full_key]
+          @values[k] = klass.construct_from(v)
+        elsif obj_list_keys.has_key?(full_key)
+          klass = obj_list_keys[full_key]
+          @values[k] = []
+          v.each do |i|
+            @values[k].push(klass.construct_from(i))
+          end
+        else
+          @values[k] = v
+        end
+      end
+    end
+
+    def [](k)
+      k = k.to_sym if k.kind_of?(String)
+      @values[k]
+    end
+
+    def []=(k, v)
+      k = k.to_sym if k.kind_of?(String)
+      send(:"#{k}=", v)
+    end
+
+    def has_key?(k)
+      k = k.to_sym if k.kind_of?(String)
+      @values.has_key?(k)
+    end
+    
+    def delete(k)
+      k = k.to_sym if k.kind_of?(String)
+      @values.delete(k)
+      remove_accessors([k])
+    end
+    
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      Postmaster::JSON.dump(@values)
+    end
+
+    def to_hash
+      result = @values.clone
+      result.each do |k, v|
+        if v.kind_of? Postmaster::PostmasterObject
+          result[k] = v.to_hash
+        elsif v.kind_of? Array and v[0].kind_of? Postmaster::PostmasterObject
+          result[k] = v.map { |i| i.to_hash }
+        end
+      end
+      result
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            @values[k] = v
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        @values[attr] = args[0]
+        add_accessors([attr])
+        return
+      else
+        return @values[name] if @values.has_key?(name)
+      end
+
+      super
+    end
+  end
+end

data/lib/postmaster/shipment.rb

@@ -0,0 +1,21 @@
+module Postmaster
+  
+  class Shipment < APIResource
+    include Postmaster::APIOperations::Create
+    include Postmaster::APIOperations::List
+    
+    def track
+      response = Postmaster.request(:get, url('track'))
+      if response[:results].nil?
+        return nil
+      end
+      response[:results].map { |i| Postmaster::Tracking.construct_from(i) }
+    end
+    
+    def void
+      response = Postmaster.request(:post, url('void'))
+      refresh_from({})
+      response[:message] == 'OK'
+    end
+  end
+end

data/lib/postmaster/tracking.rb

@@ -0,0 +1,9 @@
+module Postmaster
+
+  class Tracking < APIResource
+  end
+
+  class TrackingHistory < APIResource
+  end
+  
+end

data/lib/postmaster/util.rb

@@ -0,0 +1,68 @@
+module Postmaster
+  module Util
+
+    def self.objects_to_ids(h)
+      case h
+      when APIResource
+        h.id
+      when Hash
+        res = {}
+        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+        res
+      when Array
+        h.map { |v| objects_to_ids(v) }
+      else
+        h
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new[key] = symbolize_names(value)
+        end
+        new
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+    def self.url_encode(key)
+      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.flatten_params(params, parent_key=nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+  end
+end

data/lib/postmaster/version.rb

@@ -0,0 +1,3 @@
+module Postmaster
+  VERSION = '1.0.0'
+end

data/postmaster.gemspec

@@ -0,0 +1,26 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'postmaster/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'postmaster'
+  s.version = Postmaster::VERSION
+  s.summary = 'Library for postmaster.io service'
+  s.description = 'Postmaster takes the pain out of sending shipments via UPS, Fedex, and USPS. Save money before you ship, while you ship, and after you ship. See https://postmaster.io for details.'
+  s.authors = ['Postmaster']
+  s.email = ['support@postmaster.io']
+  s.homepage = 'https://postmaster.io'
+  s.require_paths = %w{lib}
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('multi_json', '>= 1.0.4', '< 2')
+
+  s.add_development_dependency('mocha')
+  s.add_development_dependency('shoulda')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ['lib']
+end

data/test/test_address.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+require 'test/unit'
+require 'postmaster'
+require 'rubygems'
+require 'shoulda'
+require 'mocha'
+require 'rest-client'
+require 'cgi'
+require 'uri'
+
+class TestAddressRuby < Test::Unit::TestCase
+  include Mocha
+ 
+  sample_address = 
+ 
+  context "Address" do
+
+    should "be valid" do
+      result = Postmaster::AddressValidation.validate({
+        :company => "Asls",
+        :contact => "Joe Smith",
+        :line1 => "1110 Algarita Ave",
+        :city => "Austin",
+        :state => "TX",
+        :zip_code => "78704",
+        :country => "US",
+      })
+      
+      assert_instance_of(Postmaster::AddressValidation, result);
+      assert(result.keys.include?(:status))
+      assert_kind_of(Array, result[:addresses])
+      assert(!result[:addresses].empty?)
+      
+      address = result[:addresses][0]
+      assert_instance_of(Postmaster::Address, address);
+      assert(address.keys.include?(:zip_code))
+      assert_equal("78704", address[:zip_code])
+    end
+    
+    should "be invalid" do
+      result = Postmaster::AddressValidation.validate({
+        :company => "Asls",
+        :contact => "Joe Smith",
+        :line1 => "007 Nowhere Ave",
+        :city => "Austin",
+        :state => "TX",
+        :zip_code => "00001",
+        :country => "US",
+      })
+      
+      assert_instance_of(Postmaster::AddressValidation, result);
+      assert(result.keys.include?(:status))
+      assert_equal("WRONG_ADDRESS", result[:status])
+    end
+    
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,63 @@
+require 'stringio'
+require 'test/unit'
+require 'postmaster'
+require 'mocha'
+include Mocha
+
+#monkeypatch request methods
+module Postmaster   
+  @mock_rest_client = nil
+
+  def self.mock_rest_client=(mock_client)
+    @mock_rest_client = mock_client
+  end
+
+  def self.api_key
+    ENV['PM_API_KEY'] || @@api_key
+  end
+  
+  def self.api_base
+    ENV['PM_API_HOST'] || @@api_base
+  end
+  
+  # remeber original execute before monkey-patching it
+  class << Postmaster
+    alias_method :original_execute_request, :execute_request
+  end
+    
+  def self.execute_request(opts)
+    # send calls to mock if it's defined otherwise call real service
+    if @mock_rest_client
+      get_params = (opts[:headers] || {})[:params]
+      post_params = opts[:payload]
+      case opts[:method]
+        when :get then @mock_rest_client.get opts[:url], get_params, post_params
+        when :post then @mock_rest_client.post opts[:url], get_params, post_params
+        when :delete then @mock_rest_client.delete opts[:url], get_params, post_params
+      end
+    else
+      original_execute_request(opts)
+    end
+  end
+end
+
+def test_response(body, code=200)
+  # When an exception is raised, restclient clobbers method_missing.  Hence we
+  # can't just use the stubs interface.
+  body = MultiJson.dump(body) if !(body.kind_of? String)
+  m = mock
+  m.instance_variable_set('@postmaster_values', { :body => body, :code => code })
+  def m.body; @postmaster_values[:body]; end
+  def m.code; @postmaster_values[:code]; end
+  m
+end
+
+
+def test_invalid_api_key_error
+  {
+    "error" => {
+      "type" => "invalid_request_error",
+      "message" => "Invalid API Key provided: invalid"
+    }
+  }
+end