active_shipping 0.9.13 → 0.9.14

data/README.markdown

@@ -1,14 +1,11 @@
 # Active Shipping
 
-This library is meant to interface with the web services of various shipping carriers. The goal is to abstract the features that are most frequently used into a pleasant and consistent Ruby API. Active Shipping is an extension of [Active Merchant][], and as such, it borrows heavily from conventions used in the latter.
+This library interfaces with the web services of various shipping carriers. The goal is to abstract the features that are most frequently used into a pleasant and consistent Ruby API. Active Shipping is an extension of [Active Merchant][], and as such, it borrows heavily from conventions used in the latter.
 
-We are starting out by only implementing the ability to list available shipping rates for a particular origin, destination, and set of packages. Further development could take advantage of other common features of carriers' web services such as tracking orders and printing labels.
-
-Active Shipping is currently being used and improved in a production environment for the e-commerce application [Shopify][]. Development is being done by [James MacAulay][] (<james@jadedpixel.com>). Discussion is welcome in the [Active Merchant Google Group][discuss].
+Active Shipping is currently being used and improved in a production environment for [Shopify][]. Development is being done by the Shopify integrations team (<integrations-team@shopify.com>). Discussion is welcome in the [Active Merchant Google Group][discuss].
 
 [Active Merchant]:http://www.activemerchant.org
 [Shopify]:http://www.shopify.com
-[James MacAulay]:http://jmacaulay.net
 [discuss]:http://groups.google.com/group/activemerchant
 
 ## Supported Shipping Carriers
@@ -20,28 +17,11 @@ Active Shipping is currently being used and improved in a production environment
 * [New Zealand Post](http://www.nzpost.co.nz)
 * more soon!
 
-## Prerequisites
-
-* [active_support](http://github.com/rails/rails/tree/master/activesupport)
-* [xml_node](http://github.com/tobi/xml_node/) (right now a version of it is actually included in this library, so you don't need to worry about it yet)
-* [mocha](http://mocha.rubyforge.org/) for the tests
-
-## Download & Installation
-
-Currently this library is available on GitHub:
-
-  <http://github.com/Shopify/active_shipping>
-
-You will need to get [Git][] if you don't have it. Then:
+## Installation
 
-  > git clone git://github.com/Shopify/active_shipping.git
+    gem install active_shipping
 
-(That URL is case-sensitive, so watch out.)
-  
-Active Shipping includes an init.rb file. This means that Rails will automatically load it on startup. Check out [git-archive][] for exporting the file tree from your repository to your vendor directory.
-
-[Git]:http://git.or.cz/
-[git-archive]:http://www.kernel.org/pub/software/scm/git/docs/git-archive.html
+...or add it to your [Gemfile](http://gembundler.com/).
 
 ## Sample Usage
 
@@ -111,23 +91,27 @@ Active Shipping includes an init.rb file. This means that Rails will automatical
     # Scanned at FedEx sort facility at KNOXVILLE, TN on Fri Oct 24 05:56:00 UTC 2008. 
     # Delivered at Knoxville, TN on Fri Oct 24 16:45:00 UTC 2008. Signed for by: T.BAKER
 
-## TODO
+## Running the tests
 
-* proper documentation
-* carrier code template generator
-* more carriers
-* support more features for existing carriers
-* bin-packing algorithm (preferably implemented in ruby)
-* order tracking
-* label printing
+After installing dependencies with `bundle install`, you can run the unit tests with `rake test:units` and the remote tests with `rake test:remote`. The unit tests mock out requests and responses so that everything runs locally, while the remote tests actually hit the carrier servers. For the remote tests, you'll need valid test credentials for any carriers' tests you want to run. The credentials should go in ~/.active_merchant/fixtures.yml, and the format of that file can be seen in the included [fixtures.yml](https://github.com/Shopify/active_shipping/blob/master/test/fixtures.yml).
 
 ## Contributing
 
 Yes, please! Take a look at the tests and the implementation of the Carrier class to see how the basics work. At some point soon there will be a carrier template generator along the lines of the gateway generator included in Active Merchant, but carrier.rb outlines most of what's necessary. The other main classes that would be good to familiarize yourself with are Location, Package, and Response.
 
-The nicest way to submit changes would be to set up a GitHub account and fork this project, then initiate a pull request when you want your changes looked at. You can also make a patch (preferably with [git-diff][]) and email to james@jadedpixel.com.
+For the features you add, you should have both unit tests and remote tests. It's probably best to start with the remote tests, and then log those requests and responses and use them as the mocks for the unit tests. You can see how this works with the USPS tests right now:
+
+https://github.com/Shopify/active_shipping/blob/master/test/remote/usps_test.rb
+https://github.com/Shopify/active_shipping/blob/master/test/unit/carriers/usps_test.rb
+https://github.com/Shopify/active_shipping/tree/master/test/fixtures/xml/usps
+
+To log requests and responses, just set the `logger` on your carrier class to some kind of `Logger` object:
+
+    USPS.logger = Logger.new($stdout)
+
+(This logging functionality is provided by the [`PostsData` module](https://github.com/Shopify/active_utils/blob/master/lib/active_utils/common/posts_data.rb) in the `active_utils` dependency.)
 
-[git-diff]:http://www.kernel.org/pub/software/scm/git/docs/git-diff.html
+After you've pushed your well-tested changes to your github fork, make a pull request and we'll take it from there!
 
 ## Contributors
 
@@ -139,4 +123,4 @@ The nicest way to submit changes would be to set up a GitHub account and fork th
 
 ## Legal Mumbo Jumbo
 
-Unless otherwise noted in specific files, all code in the Active Shipping project is under the copyright and license described in the included MIT-LICENSE file.
+Unless otherwise noted in specific files, all code in the Active Shipping project is under the copyright and license described in the included MIT-LICENSE file.

data/lib/active_shipping.rb

@@ -35,7 +35,7 @@ autoload :XmlNode, 'vendor/xml_node/lib/xml_node'
 autoload :Quantified, 'vendor/quantified/lib/quantified'
 
 require 'net/https'
-require 'active_merchant/common'
+require 'active_utils'
 
 require 'active_shipping/shipping/base'
 require 'active_shipping/shipping/response'
@@ -45,5 +45,6 @@ require 'active_shipping/shipping/package'
 require 'active_shipping/shipping/location'
 require 'active_shipping/shipping/rate_estimate'
 require 'active_shipping/shipping/shipment_event'
+require 'active_shipping/shipping/shipment_packer'
 require 'active_shipping/shipping/carrier'
 require 'active_shipping/shipping/carriers'

data/lib/active_shipping/shipping/carriers/canada_post.rb

@@ -153,15 +153,14 @@ module ActiveMerchant
         boxes = []
         if success
           xml.elements.each('eparcel/ratesAndServicesResponse/product') do |product|
-            service_name = (@options[:french] ? @@name_french : @@name) + product.get_text('name').to_s
+            service_name = (@options[:french] ? @@name_french : @@name) + " " + product.get_text('name').to_s
             service_code = product.attribute('id').to_s
-            delivery_date = date_for(product.get_text('deliveryDate').to_s)
 
             rate_estimates << RateEstimate.new(origin, destination, @@name, service_name,
               :service_code => service_code,
               :total_price => product.get_text('rate').to_s,
-              :delivery_date => delivery_date,
-              :currency => 'CAD'
+              :currency => 'CAD',
+              :delivery_range => [product.get_text('deliveryDate').to_s] * 2
             )
           end
 
@@ -209,12 +208,6 @@ module ActiveMerchant
 
         CanadaPostRateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :boxes => boxes, :postal_outlets => postal_outlets)
       end
-      
-      def date_for(string)
-        string && Time.parse(string)
-      rescue ArgumentError
-        nil
-      end
 
       def response_success?(xml)
         value = xml.get_text('eparcel/ratesAndServicesResponse/statusCode').to_s
@@ -265,4 +258,4 @@ module ActiveMerchant
       end
     end
   end
-end
+end

data/lib/active_shipping/shipping/carriers/fedex.rb

@@ -86,10 +86,7 @@ module ActiveMerchant
       }
 
       def self.service_name_for_code(service_code)
-        ServiceTypes[service_code] || begin
-          name = service_code.downcase.split('_').collect{|word| word.capitalize }.join(' ')
-          "FedEx #{name.sub(/Fedex /, '')}"
-        end
+        ServiceTypes[service_code] || "FedEx #{service_code.titleize.sub(/Fedex /, '')}"
       end
       
       def requirements
@@ -218,6 +215,8 @@ module ActiveMerchant
           xml_node << XmlNode.new('Address') do |address_node|
             address_node << XmlNode.new('PostalCode', location.postal_code)
             address_node << XmlNode.new("CountryCode", location.country_code(:alpha2))
+
+            address_node << XmlNode.new("Residential", true) unless location.commercial?
           end
         end
       end
@@ -244,7 +243,7 @@ module ActiveMerchant
                               :total_price => rated_shipment.get_text('RatedShipmentDetails/ShipmentRateDetail/TotalNetCharge/Amount').to_s.to_f,
                               :currency => currency,
                               :packages => packages,
-                              :delivery_date => rated_shipment.get_text('DeliveryTimestamp').to_s)
+                              :delivery_range => [rated_shipment.get_text('DeliveryTimestamp').to_s] * 2)
 	    end
 		
         if rate_estimates.empty?
@@ -316,7 +315,7 @@ module ActiveMerchant
       
       def response_message(document)
         response_node = response_status_node(document)
-        "#{response_status_node(document).get_text('Severity').to_s} - #{response_node.get_text('Code').to_s}: #{response_node.get_text('Message').to_s}"
+        "#{response_status_node(document).get_text('Severity')} - #{response_node.get_text('Code')}: #{response_node.get_text('Message')}"
       end
       
       def commit(request, test = false)

data/lib/active_shipping/shipping/carriers/new_zealand_post.rb

@@ -2,138 +2,268 @@ module ActiveMerchant
   module Shipping
     class NewZealandPost < Carrier
 
-      # class NewZealandPostRateResponse < RateResponse
-      # end
-      
       cattr_reader :name
       @@name = "New Zealand Post"
 
-      URL = "http://workshop.nzpost.co.nz/api/v1/rate.xml"
+      URL = "http://api.nzpost.co.nz/ratefinder"
 
-      # Override to return required keys in options hash for initialize method.
       def requirements
         [:key]
       end
 
-      # Override with whatever you need to get the rates
       def find_rates(origin, destination, packages, options = {})
-        packages = Array(packages)
-        rate_responses = []
-        packages.each do |package|
-          if package.tube?
-            request_hash = build_tube_request_params(origin, destination, package, options)
-          else
-            request_hash = build_rectangular_request_params(origin, destination, package, options)
-          end
-          url = URL + '?' + request_hash.to_param
-          response = ssl_get(url)
-          rate_responses << parse_rate_response(origin, destination, package, response, options)
-        end
-        combine_rate_responses(rate_responses, packages)
-      end
-
-      def maximum_weight
-        Mass.new(20, :kilograms)
+        options = @options.merge(options)
+        request = RateRequest.from(origin, destination, packages, options)
+        request.raw_responses = commit(request.urls) if request.new_zealand_origin?
+        request.rate_response
       end
 
       protected
 
-      # Override in subclasses for non-U.S.-based carriers.
-      def self.default_location
-        Location.new(:postal_code => '6011')
+      def commit(urls)
+        save_request(urls).map { |url| ssl_get(url) }
       end
 
-      private
-
-      def build_rectangular_request_params(origin, destination,  package, options = {})
-        params = {
-          :postcode_src => origin.postal_code,
-          :postcode_dest => destination.postal_code,
-          :api_key => @options[:key],
-          :height => "#{package.centimetres(:height) * 10}",
-          :thickness => "#{package.centimetres(:width) * 10}",
-          :length => "#{package.centimetres(:length) * 10}",
-          :weight =>"%.1f" % (package.weight.amount / 1000.0)
-        }
+      def self.default_location
+        Location.new({
+          :country => "NZ",
+          :city => "Wellington",
+          :address1 => "22 Waterloo Quay",
+          :address2 => "Pipitea",
+          :postal_code => "6011"
+        })
       end
 
-      def build_tube_request_params(origin, destination,  package, options = {})
-        params = {
-          :postcode_src => origin.postal_code,
-          :postcode_dest => destination.postal_code,
-          :api_key => @options[:key],
-          :diameter => "#{package.centimetres(:width) * 10}",
-          :length => "#{package.centimetres(:length) * 10}",
-          :weight => "%.1f" % (package.weight.amount / 1000.0)
-        }
+      class NewZealandPostRateResponse < RateResponse
+
+        attr_reader :raw_responses
+
+        def initialize(success, message, params = {}, options = {})
+          @raw_responses = options[:raw_responses]
+          super
+        end
       end
 
-      def parse_rate_response(origin, destination, package, response, options={})
-        xml = REXML::Document.new(response)
-        if response_success?(xml)
-          rate_estimates = []
-          xml.elements.each('hash/products/product') do |prod|
-            if( prod.get_text('packaging') == 'postage_only' )
-              rate_estimates << RateEstimate.new(origin, 
-                                                 destination,
-                                                 @@name,
-                                                 prod.get_text('service-group-description').to_s,
-                                                 :total_price => prod.get_text('cost').to_s.to_f,
-                                                 :currency => 'NZD',
-                                                 :service_code => prod.get_text('code').to_s,
-                                                 :package => package)
-            end
+      class RateRequest
+
+        attr_reader :urls
+        attr_writer :raw_responses
+
+        def self.from(*args)
+          return International.new(*args) unless domestic?(args[0..1])
+          Domestic.new(*args)
+        end
+
+        def initialize(origin, destination, packages, options)
+          @origin = Location.from(origin)
+          @destination = Location.from(destination)
+          @packages = Array(packages).map { |package| NewZealandPostPackage.new(package, api) }
+          @params = { :format => "json", :api_key => options[:key] }
+          @test = options[:test]
+          @rates = @responses = @raw_responses = []
+          @urls = @packages.map { |package| url(package) }
+        end
+
+        def rate_response
+          @rates = rates
+          NewZealandPostRateResponse.new(true, "success", response_params, response_options)
+        rescue => error
+          NewZealandPostRateResponse.new(false, error.message, response_params, response_options)
+        end
+
+        def new_zealand_origin?
+          self.class.new_zealand?(@origin)
+        end
+
+        protected
+
+        def self.new_zealand?(location)
+          [ 'NZ', nil ].include?(Location.from(location).country_code)
+        end
+
+        def self.domestic?(locations)
+          locations.select { |location| new_zealand?(location) }.size == 2
+        end
+
+        def response_options
+          {
+            :rates => @rates,
+            :raw_responses => @raw_responses,
+            :request => @urls,
+            :test => @test
+          }
+        end
+
+        def response_params
+          { :responses => @responses }
+        end
+
+        def rate_options(products)
+          {
+            :total_price => products.sum { |product| price(product) },
+            :currency => "NZD",
+            :service_code => products.first["code"]
+          }
+        end
+
+        def rates
+          rates_hash.map do |service, products|
+            RateEstimate.new(@origin, @destination, NewZealandPost.name, service, rate_options(products))
           end
-          
-          RateResponse.new(true, "Success", Hash.from_xml(response), :rates => rate_estimates, :xml => response)
-        else
-          error_message = response_message(xml)
-          RateResponse.new(false, error_message, Hash.from_xml(response), :rates => rate_estimates, :xml => response)
         end
-      end
 
-      def combine_rate_responses(rate_responses, packages)
-        #if there are any failed responses, return on that response
-        rate_responses.each do |r|
-          return r if !r.success?
+        def rates_hash
+          products_hash.select { |service, products| products.size == @packages.size }
         end
 
-        #group rate estimates by delivery type so that we can exclude any incomplete delviery types
-        rate_estimate_delivery_types = {}
-        rate_responses.each do |rr|
-          rr.rate_estimates.each do |re|
-            (rate_estimate_delivery_types[re.service_code] ||= []) << re
+        def products_hash
+          product_arrays.flatten.group_by { |product| service_name(product) }
+        end
+
+        def product_arrays
+          responses.map do |response|
+            raise(response["message"]) unless response["status"] == "success"
+            response["products"]
           end
         end
-        rate_estimate_delivery_types.delete_if{ |type, re| re.size != packages.size }
-
-        #combine cost estimates for remaining packages
-        combined_rate_estimates = []
-        rate_estimate_delivery_types.each do |type, re|
-          total_price = re.sum(&:total_price)
-          r = re.first
-          combined_rate_estimates << RateEstimate.new(r.origin, r.destination, r.carrier,
-                                                     r.service_name,
-                                                     :total_price => total_price,
-                                                     :currency => r.currency,
-                                                     :service_code => r.service_code,
-                                                     :packages => packages)
-        end
-        RateResponse.new(true, "Success", {}, :rates => combined_rate_estimates)
+
+        def responses
+          @responses = @raw_responses.map { |response| parse_response(response) }
+        end
+
+        def parse_response(response)
+          JSON.parse(response)
+        end
+
+        def url(package)
+          "#{URL}/#{api}?#{params(package).to_query}"
+        end
+
+        def params(package)
+          @params.merge(api_params).merge(package.params)
+        end
+
       end
 
-      def response_success?(xml)
-        xml.get_text('hash/status').to_s == 'success'
+      class Domestic < RateRequest
+        def service_name(product)
+          [ product["service_group_description"], product["description"] ].join(" ")
+        end
+        
+        def api
+          :domestic
+        end
+
+        def api_params
+          {
+            :postcode_src => @origin.postal_code,
+            :postcode_dest => @destination.postal_code,
+            :carrier => "all"
+          }
+        end
+
+        def price(product)
+          product["cost"].to_f
+        end
       end
 
-      def response_message(xml)
-        if response_success?(xml)
-          'Success'
-        else
-          xml.get_text('hash/message').to_s
+      class International < RateRequest
+
+        def rates
+          raise "New Zealand Post packages must originate in New Zealand" unless new_zealand_origin?
+          super
+        end
+
+        def service_name(product)
+          [ product["group"], product["name"] ].join(" ")
+        end
+        
+        def api
+          :international
+        end
+
+        def api_params
+          { :country_code => @destination.country_code }
+        end
+        
+        def price(product)
+          product["price"].to_f
         end
       end
 
+      class NewZealandPostPackage
+
+        def initialize(package, api)
+          @package = package
+          @api = api
+          @params = { :weight => weight, :length => length }
+        end
+
+        def params
+          @params.merge(api_params).merge(shape_params)
+        end
+
+        protected
+
+        def weight
+          @package.kg
+        end
+
+        def length
+          mm(:length)
+        end
+
+        def height
+          mm(:height)
+        end
+
+        def width
+          mm(:width)
+        end
+
+        def shape
+          return :cylinder if @package.cylinder?
+          :cuboid
+        end
+
+        def api_params
+          send("#{@api}_params")
+        end
+
+        def international_params
+          { :value => value }
+        end
+
+        def domestic_params
+          {}
+        end
+
+        def shape_params
+          send("#{shape}_params")
+        end
+
+        def cuboid_params
+          { :height => height, :thickness => width }
+        end
+
+        def cylinder_params
+          { :diameter => width }
+        end
+
+        def mm(measurement)
+          @package.cm(measurement) * 10
+        end
+
+        def value
+          return 0 unless @package.value && currency == "NZD"
+          @package.value / 100
+        end
+
+        def currency
+          @package.currency || "NZD"
+        end
+
+      end
     end
   end
 end