active_shipping 0.12.5 → 0.12.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1976e71d35364954a7b796b394000fa996d3e0b1
-  data.tar.gz: 0c143eefaaf19b10cfaba63e01110164024b3bae
+  metadata.gz: 715dd60ad9d4a6fbe5c9ba36834326fa383c4ee4
+  data.tar.gz: 1f1991bf39492b70a068e92e52bb687f4b3526b4
 SHA512:
-  metadata.gz: 312abbbb1fd246d4f6221cbf4fa7f70101465d118ff18bc2c588be8f276904e90ee9a9666d90b745a3d29c6abe1cc615230f188e7a6acb759374977a88ce2838
-  data.tar.gz: db9d8dccf1c806d521188f99fff5b72eb7704da60359bb4239fa293e21be21e646373a0d42fd5df901b597e224bcb5ccd7d7a0c617607c2375242456df1a8843
+  metadata.gz: 725e84ee191ce38e56e89a3af8ff0592c21a5e6bc6f584edf9cfdcc4fbb01a5532bc999ae28dfc07045fa403cb8f86c363b8d62e12441fc488efe0e863c33645
+  data.tar.gz: db8156ebcbd65a863f222b7bdfb26b37ac3fbd5a6b4e9036fc499488133a7075ec9906f996cafdce5b4ccc002b2e08fabdeffaabf59c82c7da26430ce4519a6a

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

@@ -264,7 +264,7 @@ module ActiveMerchant
       end
 
       def world_rates(origin, destination, packages, options = {})
-        request = build_world_rate_request(packages, destination, options)
+        request = build_world_rate_request(origin, packages, destination, options)
         # never use test mode; rate requests just won't work on test servers
         parse_rate_response origin, destination, packages, commit(:world_rates, request, false), options
       end
@@ -343,9 +343,10 @@ module ActiveMerchant
       #
       # package.options[:mail_type] -- one of [:package, :postcard, :matter_for_the_blind, :envelope].
       #                                 Defaults to :package.
-      def build_world_rate_request(packages, destination, options)
+      def build_world_rate_request(origin, packages, destination, options)
         country = COUNTRY_NAME_CONVERSIONS[destination.country.code(:alpha2).value] || destination.country.name
         request = XmlNode.new('IntlRateV2Request', :USERID => @options[:login]) do |rate_request|
+          rate_request << XmlNode.new('Revision', 2)
           packages.each_index do |id|
             p = packages[id]
             rate_request << XmlNode.new('Package', :ID => id.to_s) do |package|
@@ -374,6 +375,9 @@ module ActiveMerchant
               if commercial_type = commercial_type(options)
                 package << XmlNode.new(COMMERCIAL_FLAG_NAME.fetch(commercial_type), 'Y')
               end
+              package << XmlNode.new('OriginZip', origin.zip)
+              package << XmlNode.new('AcceptanceDateTime', (options[:acceptance_time] || Time.now.utc).iso8601)
+              package << XmlNode.new('DestinationPostalCode', destination.zip)
             end
           end
         end

data/lib/active_shipping/version.rb

@@ -1,3 +1,3 @@
 module ActiveShipping
-  VERSION = "0.12.5"
+  VERSION = "0.12.6"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_shipping
 version: !ruby/object:Gem::Version
-  version: 0.12.5
+  version: 0.12.6
 platform: ruby
 authors:
 - James MacAulay
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-16 00:00:00.000000000 Z
+date: 2015-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -177,9 +177,7 @@ files:
 - lib/active_shipping/shipping/carriers/shipwire.rb
 - lib/active_shipping/shipping/carriers/stamps.rb
 - lib/active_shipping/shipping/carriers/ups.rb
-- lib/active_shipping/shipping/carriers/ups.rb.orig
 - lib/active_shipping/shipping/carriers/usps.rb
-- lib/active_shipping/shipping/carriers/usps.rb.orig
 - lib/active_shipping/shipping/errors.rb
 - lib/active_shipping/shipping/label_response.rb
 - lib/active_shipping/shipping/location.rb

data/lib/active_shipping/shipping/carriers/ups.rb.orig

@@ -1,456 +0,0 @@
-# -*- encoding: utf-8 -*-
-
-module ActiveMerchant
-  module Shipping
-    class UPS < Carrier
-      self.retry_safe = true
-      
-      cattr_accessor :default_options
-      cattr_reader :name
-      @@name = "UPS"
-      
-      TEST_URL = 'https://wwwcie.ups.com'
-      LIVE_URL = 'https://onlinetools.ups.com'
-      
-      RESOURCES = {
-        :rates => 'ups.app/xml/Rate',
-        :track => 'ups.app/xml/Track'
-      }
-      
-      PICKUP_CODES = HashWithIndifferentAccess.new({
-        :daily_pickup => "01",
-        :customer_counter => "03", 
-        :one_time_pickup => "06",
-        :on_call_air => "07",
-        :suggested_retail_rates => "11",
-        :letter_center => "19",
-        :air_service_center => "20"
-      })
-
-      CUSTOMER_CLASSIFICATIONS = HashWithIndifferentAccess.new({
-        :wholesale => "01",
-        :occasional => "03", 
-        :retail => "04"
-      })
-
-      # these are the defaults described in the UPS API docs,
-      # but they don't seem to apply them under all circumstances,
-      # so we need to take matters into our own hands
-      DEFAULT_CUSTOMER_CLASSIFICATIONS = Hash.new do |hash,key|
-        hash[key] = case key.to_sym
-        when :daily_pickup then :wholesale
-        when :customer_counter then :retail
-        else
-          :occasional
-        end
-      end
-      
-      DEFAULT_SERVICES = {
-        "01" => "UPS Next Day Air",
-        "02" => "UPS Second Day Air",
-        "03" => "UPS Ground",
-        "07" => "UPS Worldwide Express",
-        "08" => "UPS Worldwide Expedited",
-        "11" => "UPS Standard",
-        "12" => "UPS Three-Day Select",
-        "13" => "UPS Next Day Air Saver",
-        "14" => "UPS Next Day Air Early A.M.",
-        "54" => "UPS Worldwide Express Plus",
-        "59" => "UPS Second Day Air A.M.",
-        "65" => "UPS Saver",
-        "82" => "UPS Today Standard",
-        "83" => "UPS Today Dedicated Courier",
-        "84" => "UPS Today Intercity",
-        "85" => "UPS Today Express",
-        "86" => "UPS Today Express Saver"
-      }
-      
-      CANADA_ORIGIN_SERVICES = {
-        "01" => "UPS Express",
-        "02" => "UPS Expedited",
-        "14" => "UPS Express Early A.M."
-      }
-      
-      MEXICO_ORIGIN_SERVICES = {
-        "07" => "UPS Express",
-        "08" => "UPS Expedited",
-        "54" => "UPS Express Plus"
-      }
-      
-      EU_ORIGIN_SERVICES = {
-        "07" => "UPS Express",
-        "08" => "UPS Expedited"
-      }
-      
-      OTHER_NON_US_ORIGIN_SERVICES = {
-        "07" => "UPS Express"
-      }
-
-      TRACKING_STATUS_CODES = HashWithIndifferentAccess.new({
-        'I' => :in_transit,
-        'D' => :delivered,
-        'X' => :exception,
-        'P' => :pickup,
-        'M' => :manifest_pickup
-      })
-
-      # From http://en.wikipedia.org/w/index.php?title=European_Union&oldid=174718707 (Current as of November 30, 2007)
-      EU_COUNTRY_CODES = ["GB", "AT", "BE", "BG", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE"]
-      
-      US_TERRITORIES_TREATED_AS_COUNTRIES = ["AS", "FM", "GU", "MH", "MP", "PW", "PR", "VI"]
-      
-      def requirements
-        [:key, :login, :password]
-      end
-      
-      def find_rates(origin, destination, packages, options={})
-        origin, destination = upsified_location(origin), upsified_location(destination)
-        options = @options.merge(options)
-        packages = Array(packages)
-        access_request = build_access_request
-        rate_request = build_rate_request(origin, destination, packages, options)
-        response = commit(:rates, save_request(access_request + rate_request), (options[:test] || false))
-        parse_rate_response(origin, destination, packages, response, options)
-      end
-      
-      def find_tracking_info(tracking_number, options={})
-        options = @options.update(options)
-        access_request = build_access_request
-        tracking_request = build_tracking_request(tracking_number, options)
-        response = commit(:track, save_request(access_request + tracking_request), (options[:test] || false))
-        parse_tracking_response(response, options)
-      end
-      
-      protected
-      
-      def upsified_location(location)
-        if location.country_code == 'US' && US_TERRITORIES_TREATED_AS_COUNTRIES.include?(location.state)
-          atts = {:country => location.state}
-          [:zip, :city, :address1, :address2, :address3, :phone, :fax, :address_type].each do |att|
-            atts[att] = location.send(att)
-          end
-          Location.new(atts)
-        else
-          location
-        end
-      end
-      
-      def build_access_request
-        xml_request = XmlNode.new('AccessRequest') do |access_request|
-          access_request << XmlNode.new('AccessLicenseNumber', @options[:key])
-          access_request << XmlNode.new('UserId', @options[:login])
-          access_request << XmlNode.new('Password', @options[:password])
-        end
-        xml_request.to_s
-      end
-      
-      def build_rate_request(origin, destination, packages, options={})
-        packages = Array(packages)
-        xml_request = XmlNode.new('RatingServiceSelectionRequest') do |root_node|
-          root_node << XmlNode.new('Request') do |request|
-            request << XmlNode.new('RequestAction', 'Rate')
-            request << XmlNode.new('RequestOption', 'Shop')
-            # not implemented: 'Rate' RequestOption to specify a single service query
-            # request << XmlNode.new('RequestOption', ((options[:service].nil? or options[:service] == :all) ? 'Shop' : 'Rate'))
-          end
-          
-          pickup_type = options[:pickup_type] || :daily_pickup
-          
-          root_node << XmlNode.new('PickupType') do |pickup_type_node|
-            pickup_type_node << XmlNode.new('Code', PICKUP_CODES[pickup_type])
-            # not implemented: PickupType/PickupDetails element
-          end
-          cc = options[:customer_classification] || DEFAULT_CUSTOMER_CLASSIFICATIONS[pickup_type]
-          root_node << XmlNode.new('CustomerClassification') do |cc_node|
-            cc_node << XmlNode.new('Code', CUSTOMER_CLASSIFICATIONS[cc])
-          end
-          
-          root_node << XmlNode.new('Shipment') do |shipment|
-            # not implemented: Shipment/Description element
-            shipment << build_location_node('Shipper', (options[:shipper] || origin), options)
-            shipment << build_location_node('ShipTo', destination, options)
-            if options[:shipper] and options[:shipper] != origin
-              shipment << build_location_node('ShipFrom', origin, options)
-            end
-            
-            # not implemented:  * Shipment/ShipmentWeight element
-            #                   * Shipment/ReferenceNumber element                    
-            #                   * Shipment/Service element                            
-            #                   * Shipment/PickupDate element                         
-            #                   * Shipment/ScheduledDeliveryDate element              
-            #                   * Shipment/ScheduledDeliveryTime element              
-            #                   * Shipment/AlternateDeliveryTime element              
-            #                   * Shipment/DocumentsOnly element                      
-            
-            packages.each do |package|
-              imperial = ['US','LR','MM'].include?(origin.country_code(:alpha2))
-              
-              shipment << XmlNode.new("Package") do |package_node|
-                
-                # not implemented:  * Shipment/Package/PackagingType element
-                #                   * Shipment/Package/Description element
-                
-                package_node << XmlNode.new("PackagingType") do |packaging_type|
-                  packaging_type << XmlNode.new("Code", '02')
-                end
-                
-                package_node << XmlNode.new("Dimensions") do |dimensions|
-                  dimensions << XmlNode.new("UnitOfMeasurement") do |units|
-                    units << XmlNode.new("Code", imperial ? 'IN' : 'CM')
-                  end
-                  [:length,:width,:height].each do |axis|
-                    value = ((imperial ? package.inches(axis) : package.cm(axis)).to_f*1000).round/1000.0 # 3 decimals
-                    dimensions << XmlNode.new(axis.to_s.capitalize, [value,0.1].max)
-                  end
-                end
-              
-                package_node << XmlNode.new("PackageWeight") do |package_weight|
-                  package_weight << XmlNode.new("UnitOfMeasurement") do |units|
-                    units << XmlNode.new("Code", imperial ? 'LBS' : 'KGS')
-                  end
-                  
-                  value = ((imperial ? package.lbs : package.kgs).to_f*1000).round/1000.0 # 3 decimals
-                  package_weight << XmlNode.new("Weight", [value,0.1].max)
-                end
-              
-                # not implemented:  * Shipment/Package/LargePackageIndicator element
-                #                   * Shipment/Package/ReferenceNumber element
-                #                   * Shipment/Package/PackageServiceOptions element
-                #                   * Shipment/Package/AdditionalHandling element  
-              end
-              
-            end
-            
-            # not implemented:  * Shipment/ShipmentServiceOptions element
-            if options[:origin_account]
-              shipment << XmlNode.new("RateInformation") do |rate_info_node|
-                rate_info_node << XmlNode.new("NegotiatedRatesIndicator")
-              end
-            end
-            
-          end
-          
-        end
-        xml_request.to_s
-      end
-      
-      def build_tracking_request(tracking_number, options={})
-        xml_request = XmlNode.new('TrackRequest') do |root_node|
-          root_node << XmlNode.new('Request') do |request|
-            request << XmlNode.new('RequestAction', 'Track')
-            request << XmlNode.new('RequestOption', '1')
-          end
-          root_node << XmlNode.new('TrackingNumber', tracking_number.to_s)
-        end
-        xml_request.to_s
-      end
-      
-      def build_location_node(name,location,options={})
-        # not implemented:  * Shipment/Shipper/Name element
-        #                   * Shipment/(ShipTo|ShipFrom)/CompanyName element
-        #                   * Shipment/(Shipper|ShipTo|ShipFrom)/AttentionName element
-        #                   * Shipment/(Shipper|ShipTo|ShipFrom)/TaxIdentificationNumber element
-        location_node = XmlNode.new(name) do |location_node|
-          location_node << XmlNode.new('PhoneNumber', location.phone.gsub(/[^\d]/,'')) unless location.phone.blank?
-          location_node << XmlNode.new('FaxNumber', location.fax.gsub(/[^\d]/,'')) unless location.fax.blank?
-          
-          if name == 'Shipper' and (origin_account = @options[:origin_account] || options[:origin_account])
-            location_node << XmlNode.new('ShipperNumber', origin_account)
-          elsif name == 'ShipTo' and (destination_account = @options[:destination_account] || options[:destination_account])
-            location_node << XmlNode.new('ShipperAssignedIdentificationNumber', destination_account)
-          end
-          
-          location_node << XmlNode.new('Address') do |address|
-            address << XmlNode.new("AddressLine1", location.address1) unless location.address1.blank?
-            address << XmlNode.new("AddressLine2", location.address2) unless location.address2.blank?
-            address << XmlNode.new("AddressLine3", location.address3) unless location.address3.blank?
-            address << XmlNode.new("City", location.city) unless location.city.blank?
-            address << XmlNode.new("StateProvinceCode", location.province) unless location.province.blank?
-              # StateProvinceCode required for negotiated rates but not otherwise, for some reason
-            address << XmlNode.new("PostalCode", location.postal_code) unless location.postal_code.blank?
-            address << XmlNode.new("CountryCode", location.country_code(:alpha2)) unless location.country_code(:alpha2).blank?
-            address << XmlNode.new("ResidentialAddressIndicator", true) unless location.commercial? # the default should be that UPS returns residential rates for destinations that it doesn't know about
-            # not implemented: Shipment/(Shipper|ShipTo|ShipFrom)/Address/ResidentialAddressIndicator element
-          end
-        end
-      end
-      
-      def parse_rate_response(origin, destination, packages, response, options={})
-        rates = []
-        File.open('/Users/timmy/code/active_shipping/foo.txt', 'w') {|f| f.write(response) }
-        xml = REXML::Document.new(response)
-        success = response_success?(xml)
-        message = response_message(xml)
-        
-        if success
-          rate_estimates = []
-          
-          xml.elements.each('/*/RatedShipment') do |rated_shipment|
-            service_code = rated_shipment.get_text('Service/Code').to_s
-            days_to_delivery = rated_shipment.get_text('GuaranteedDaysToDelivery').to_s.to_i
-            delivery_date  = days_to_delivery >= 1 ? days_to_delivery.days.from_now.strftime("%Y-%m-%d") : nil
-            rate_estimates << RateEstimate.new(origin, destination, @@name,
-                                service_name_for(origin, service_code),
-                                :total_price => rated_shipment.get_text('TotalCharges/MonetaryValue').to_s.to_f,
-                                :currency => rated_shipment.get_text('TotalCharges/CurrencyCode').to_s,
-                                :service_code => service_code,
-                                :packages => packages,
-                                :delivery_range => [delivery_date],
-                                :negotiated_rate => rated_shipment.get_text('NegotiatedRates/NetSummaryCharges/GrandTotal/MonetaryValue').to_s.to_f)
-          end
-        end
-        RateResponse.new(success, message, Hash.from_xml(response).values.first, :rates => rate_estimates, :xml => response, :request => last_request)
-      end
-      
-      def parse_tracking_response(response, options={})
-        xml = REXML::Document.new(response)
-        success = response_success?(xml)
-        message = response_message(xml)
-        
-        if success
-          tracking_number, origin, destination, status_code, status_description = nil
-          delivered, exception = false
-          exception_event = nil
-          shipment_events = []
-          status = {}
-          scheduled_delivery_date = nil
-
-          first_shipment = xml.elements['/*/Shipment']
-          first_package = first_shipment.elements['Package']
-          tracking_number = first_shipment.get_text('ShipmentIdentificationNumber | Package/TrackingNumber').to_s
-          
-          # Build status hash
-          status_node = first_package.elements['Activity/Status/StatusType']
-          status_code = status_node.get_text('Code').to_s
-          status_description = status_node.get_text('Description').to_s
-          status = TRACKING_STATUS_CODES[status_code]
-
-          if status_description =~ /out.*delivery/i
-            status = :out_for_delivery
-          end
-
-          origin, destination = %w{Shipper ShipTo}.map do |location|
-            location_from_address_node(first_shipment.elements["#{location}/Address"])
-          end
-
-          # Get scheduled delivery date
-          unless status == :delivered
-            scheduled_delivery_date = parse_ups_datetime({
-              :date => first_shipment.get_text('ScheduledDeliveryDate'),
-              :time => nil
-              })
-          end
-
-          activities = first_package.get_elements('Activity')
-          unless activities.empty?
-            shipment_events = activities.map do |activity|
-              description = activity.get_text('Status/StatusType/Description').to_s
-              zoneless_time = if (time = activity.get_text('Time')) &&
-                                 (date = activity.get_text('Date'))
-                time, date = time.to_s, date.to_s
-                hour, minute, second = time.scan(/\d{2}/)
-                year, month, day = date[0..3], date[4..5], date[6..7]
-                Time.utc(year, month, day, hour, minute, second)
-              end
-              location = location_from_address_node(activity.elements['ActivityLocation/Address'])
-              ShipmentEvent.new(description, zoneless_time, location)
-            end
-            
-            shipment_events = shipment_events.sort_by(&:time)
-            
-            # UPS will sometimes archive a shipment, stripping all shipment activity except for the delivery 
-            # event (see test/fixtures/xml/delivered_shipment_without_events_tracking_response.xml for an example).
-            # This adds an origin event to the shipment activity in such cases.
-            if origin && !(shipment_events.count == 1 && status == :delivered)
-              first_event = shipment_events[0]
-              same_country = origin.country_code(:alpha2) == first_event.location.country_code(:alpha2)
-              same_or_blank_city = first_event.location.city.blank? or first_event.location.city == origin.city
-              origin_event = ShipmentEvent.new(first_event.name, first_event.time, origin)
-              if same_country and same_or_blank_city
-                shipment_events[0] = origin_event
-              else
-                shipment_events.unshift(origin_event)
-              end
-            end
-
-            # Has the shipment been delivered?
-            if status == :delivered
-              if !destination
-                destination = shipment_events[-1].location
-              end
-              shipment_events[-1] = ShipmentEvent.new(shipment_events.last.name, shipment_events.last.time, destination)
-            end
-          end
-          
-        end
-        TrackingResponse.new(success, message, Hash.from_xml(response).values.first,
-          :carrier => @@name,
-          :xml => response,
-          :request => last_request,
-          :status => status,
-          :status_code => status_code,
-          :status_description => status_description,
-          :scheduled_delivery_date => scheduled_delivery_date,
-          :shipment_events => shipment_events,
-          :delivered => delivered,
-          :exception => exception,
-          :exception_event => exception_event,
-          :origin => origin,
-          :destination => destination,
-          :tracking_number => tracking_number)
-      end
-      
-      def location_from_address_node(address)
-        return nil unless address
-        Location.new(
-                :country =>     node_text_or_nil(address.elements['CountryCode']),
-                :postal_code => node_text_or_nil(address.elements['PostalCode']),
-                :province =>    node_text_or_nil(address.elements['StateProvinceCode']),
-                :city =>        node_text_or_nil(address.elements['City']),
-                :address1 =>    node_text_or_nil(address.elements['AddressLine1']),
-                :address2 =>    node_text_or_nil(address.elements['AddressLine2']),
-                :address3 =>    node_text_or_nil(address.elements['AddressLine3'])
-              )
-      end
-      
-      def parse_ups_datetime(options = {})
-        time, date = options[:time].to_s, options[:date].to_s
-        if time.nil?
-          hour, minute, second = 0
-        else
-          hour, minute, second = time.scan(/\d{2}/)
-        end
-        year, month, day = date[0..3], date[4..5], date[6..7]
-
-        Time.utc(year, month, day, hour, minute, second)
-      end
-
-      def response_success?(xml)
-        xml.get_text('/*/Response/ResponseStatusCode').to_s == '1'
-      end
-      
-      def response_message(xml)
-        xml.get_text('/*/Response/Error/ErrorDescription | /*/Response/ResponseStatusDescription').to_s
-      end
-      
-      def commit(action, request, test = false)
-        ssl_post("#{test ? TEST_URL : LIVE_URL}/#{RESOURCES[action]}", request)
-      end
-      
-      
-      def service_name_for(origin, code)
-        origin = origin.country_code(:alpha2)
-        
-        name = case origin
-        when "CA" then CANADA_ORIGIN_SERVICES[code]
-        when "MX" then MEXICO_ORIGIN_SERVICES[code]
-        when *EU_COUNTRY_CODES then EU_ORIGIN_SERVICES[code]
-        end
-        
-        name ||= OTHER_NON_US_ORIGIN_SERVICES[code] unless name == 'US'
-        name ||= DEFAULT_SERVICES[code]
-      end
-      
-    end
-  end
-end

data/lib/active_shipping/shipping/carriers/usps.rb.orig

@@ -1,616 +0,0 @@
-# -*- encoding: utf-8 -*-
-require 'cgi'
-
-module ActiveMerchant
-  module Shipping
-    
-    # After getting an API login from USPS (looks like '123YOURNAME456'),
-    # run the following test:
-    # 
-    # usps = USPS.new(:login => '123YOURNAME456', :test => true)
-    # usps.valid_credentials?
-    #
-    # This will send a test request to the USPS test servers, which they ask you
-    # to do before they put your API key in production mode.
-    class USPS < Carrier
-      self.retry_safe = true
-      
-      cattr_reader :name
-      @@name = "USPS"
-      
-      LIVE_DOMAIN = 'production.shippingapis.com'
-      LIVE_RESOURCE = 'ShippingAPI.dll'
-      
-      TEST_DOMAINS = { #indexed by security; e.g. TEST_DOMAINS[USE_SSL[:rates]]
-        true => 'secure.shippingapis.com',
-        false => 'testing.shippingapis.com'
-      }
-      
-      TEST_RESOURCE = 'ShippingAPITest.dll'
-      
-      API_CODES = {
-        :us_rates => 'RateV4',
-        :world_rates => 'IntlRateV2',
-        :test => 'CarrierPickupAvailability',
-        :track => 'TrackV2'
-      }
-      USE_SSL = {
-        :us_rates => false,
-        :world_rates => false,
-        :test => true,
-        :track => false
-      }
-      CONTAINERS = {
-        :envelope => 'Flat Rate Envelope',
-        :box => 'Flat Rate Box'
-      }
-      MAIL_TYPES = {
-        :package => 'Package',
-        :postcard => 'Postcards or aerogrammes',
-        :matter_for_the_blind => 'Matter for the blind',
-        :envelope => 'Envelope'
-      }
-
-      PACKAGE_PROPERTIES = {
-        'ZipOrigination' => :origin_zip,
-        'ZipDestination' => :destination_zip,
-        'Pounds' => :pounds,
-        'Ounces' => :ounces,
-        'Container' => :container,
-        'Size' => :size,
-        'Machinable' => :machinable,
-        'Zone' => :zone,
-        'Postage' => :postage,
-        'Restrictions' => :restrictions
-      }
-      POSTAGE_PROPERTIES = {
-        'MailService' => :service,
-        'Rate' => :rate
-      }
-      US_SERVICES = {
-        :first_class => 'FIRST CLASS',
-        :priority => 'PRIORITY',
-        :express => 'EXPRESS',
-        :bpm => 'BPM',
-        :parcel => 'PARCEL',
-        :media => 'MEDIA',
-        :library => 'LIBRARY',
-        :all => 'ALL'
-      }
-      FIRST_CLASS_MAIL_TYPES = {
-        :letter => 'LETTER',
-        :flat => 'FLAT',
-        :parcel => 'PARCEL',
-        :post_card => 'POSTCARD',
-        :package_service => 'PACKAGESERVICE'
-      }
-      
-      # TODO: get rates for "U.S. possessions and Trust Territories" like Guam, etc. via domestic rates API: http://www.usps.com/ncsc/lookups/abbr_state.txt
-      # TODO: figure out how USPS likes to say "Ivory Coast"
-      #
-      # Country names:
-      # http://pe.usps.gov/text/Imm/immctry.htm
-      COUNTRY_NAME_CONVERSIONS = {
-        "BA" => "Bosnia-Herzegovina",
-        "CD" => "Congo, Democratic Republic of the",
-        "CG" => "Congo (Brazzaville),Republic of the",
-        "CI" => "Côte d'Ivoire (Ivory Coast)",
-        "CK" => "Cook Islands (New Zealand)",
-        "FK" => "Falkland Islands",
-        "GB" => "Great Britain and Northern Ireland",
-        "GE" => "Georgia, Republic of",
-        "IR" => "Iran",
-        "KN" => "Saint Kitts (St. Christopher and Nevis)",
-        "KP" => "North Korea (Korea, Democratic People's Republic of)",
-        "KR" => "South Korea (Korea, Republic of)",
-        "LA" => "Laos",
-        "LY" => "Libya",
-        "MC" => "Monaco (France)",
-        "MD" => "Moldova",
-        "MK" => "Macedonia, Republic of",
-        "MM" => "Burma",
-        "PN" => "Pitcairn Island",
-        "RU" => "Russia",
-        "SK" => "Slovak Republic",
-        "TK" => "Tokelau (Union) Group (Western Samoa)",
-        "TW" => "Taiwan",
-        "TZ" => "Tanzania",
-        "VA" => "Vatican City",
-        "VG" => "British Virgin Islands",
-        "VN" => "Vietnam",
-        "WF" => "Wallis and Futuna Islands",
-        "WS" => "Western Samoa"
-      }
-
-      def find_tracking_info(tracking_number, options={})
-        options = @options.update(options)        
-        tracking_request = build_tracking_request(tracking_number, options)
-        response = commit(:track, tracking_request, (options[:test] || false))
-        parse_tracking_response(response, options)
-      end
-
-      def self.size_code_for(package)
-        if package.inches(:max) <= 12
-          'REGULAR'
-        else
-          'LARGE'
-        end
-      end
-      
-      # from info at http://www.usps.com/businessmail101/mailcharacteristics/parcels.htm
-      # 
-      # package.options[:books] -- 25 lb. limit instead of 35 for books or other printed matter.
-      #                             Defaults to false.
-      def self.package_machinable?(package, options={})
-        at_least_minimum =  package.inches(:length) >= 6.0 &&
-                            package.inches(:width) >= 3.0 &&
-                            package.inches(:height) >= 0.25 &&
-                            package.ounces >= 6.0
-        at_most_maximum  =  package.inches(:length) <= 34.0 &&
-                            package.inches(:width) <= 17.0 &&
-                            package.inches(:height) <= 17.0 &&
-                            package.pounds <= (package.options[:books] ? 25.0 : 35.0)
-        at_least_minimum && at_most_maximum
-      end
-      
-      def requirements
-        [:login]
-      end
-      
-      def find_rates(origin, destination, packages, options = {})
-        options = @options.merge(options)
-        
-        origin = Location.from(origin)
-        destination = Location.from(destination)
-        packages = Array(packages)
-        
-        #raise ArgumentError.new("USPS packages must originate in the U.S.") unless ['US',nil].include?(origin.country_code(:alpha2))
-        
-        
-        # domestic or international?
-        
-        response = if ['US',nil].include?(destination.country_code(:alpha2))
-          us_rates(origin, destination, packages, options)
-        else
-          world_rates(origin, destination, packages, options)
-        end
-      end
-      
-      def valid_credentials?
-        # Cannot test with find_rates because USPS doesn't allow that in test mode
-        test_mode? ? canned_address_verification_works? : super
-      end
-      
-      def maximum_weight
-        Mass.new(70, :pounds)
-      end
-<<<<<<< HEAD
-      
-      
-      def find_tracking_info(tracking_number, options={})
-        options = @options.update(options)
-        tracking_request = build_tracking_request(tracking_number, options)
-        response = commit(save_request(tracking_request), (options[:test] || false)).gsub(/<(\/)?.*?\:(.*?)>/, '<\1\2>')
-        parse_tracking_response(response, options)
-      end
-      
-      
-=======
-
->>>>>>> d1ef4f7... further cleanup prior to pull request
-      protected
-
-
-
-      def response_success?(xml)
-        xml.get_text('/*/Response/ResponseStatusCode').to_s == '1'
-      end
-
-      def response_message(xml)
-        xml.get_text('/*/Response/Error/ErrorDescription | /*/Response/ResponseStatusDescription').to_s
-      end
-
-      def parse_tracking_response(response, options={})
-        xml = REXML::Document.new(response)
-        success = response_success?(xml)
-        message = response_message(xml)
-        
-        if success
-          tracking_number, origin, destination = nil
-          shipment_events = []
-          
-          first_shipment = xml.elements['/*/Shipment']
-          first_package = first_shipment.elements['Package']
-          tracking_number = first_shipment.get_text('ShipmentIdentificationNumber | Package/TrackingNumber').to_s
-          
-          origin, destination = %w{Shipper ShipTo}.map do |location|
-            location_from_address_node(first_shipment.elements["#{location}/Address"])
-          end
-          
-          activities = first_package.get_elements('Activity')
-          unless activities.empty?
-            shipment_events = activities.map do |activity|
-              description = activity.get_text('Status/StatusType/Description').to_s
-              zoneless_time = if (time = activity.get_text('Time')) &&
-                                 (date = activity.get_text('Date'))
-                time, date = time.to_s, date.to_s
-                hour, minute, second = time.scan(/\d{2}/)
-                year, month, day = date[0..3], date[4..5], date[6..7]
-                Time.utc(year, month, day, hour, minute, second)
-              end
-              location = location_from_address_node(activity.elements['ActivityLocation/Address'])
-              ShipmentEvent.new(description, zoneless_time, location)
-            end
-            
-            shipment_events = shipment_events.sort_by(&:time)
-            
-            if origin
-              first_event = shipment_events[0]
-              same_country = origin.country_code(:alpha2) == first_event.location.country_code(:alpha2)
-              same_or_blank_city = first_event.location.city.blank? or first_event.location.city == origin.city
-              origin_event = ShipmentEvent.new(first_event.name, first_event.time, origin)
-              if same_country and same_or_blank_city
-                shipment_events[0] = origin_event
-              else
-                shipment_events.unshift(origin_event)
-              end
-            end
-            if shipment_events.last.name.downcase == 'delivered'
-              shipment_events[-1] = ShipmentEvent.new(shipment_events.last.name, shipment_events.last.time, destination)
-            end
-          end
-          
-        end
-        TrackingResponse.new(success, message, Hash.from_xml(response).values.first,
-          :xml => response,
-          :request => last_request,
-          :shipment_events => shipment_events,
-          :origin => origin,
-          :destination => destination,
-          :tracking_number => tracking_number)
-      end
-
-
-
-
-
-
-      def build_tracking_request(tracking_number, options={})
-        xml_request = XmlNode.new('TrackRequest', 'USERID' => @options[:login]) do |root_node|
-          root_node << XmlNode.new('TrackID', :ID => tracking_number)
-        end
-        URI.encode(xml_request.to_s)
-      end
-
-      def us_rates(origin, destination, packages, options={})
-        request = build_us_rate_request(packages, origin.zip, destination.zip, options)
-         # never use test mode; rate requests just won't work on test servers
-        parse_rate_response origin, destination, packages, commit(:us_rates,request,false), options
-      end
-      
-      def world_rates(origin, destination, packages, options={})
-        request = build_world_rate_request(packages, destination)
-         # never use test mode; rate requests just won't work on test servers
-        parse_rate_response origin, destination, packages, commit(:world_rates,request,false), options
-      end
-      
-      # Once the address verification API is implemented, remove this and have valid_credentials? build the request using that instead.
-      def canned_address_verification_works?
-        request = "%3CCarrierPickupAvailabilityRequest%20USERID=%22#{URI.encode(@options[:login])}%22%3E%20%0A%3CFirmName%3EABC%20Corp.%3C/FirmName%3E%20%0A%3CSuiteOrApt%3ESuite%20777%3C/SuiteOrApt%3E%20%0A%3CAddress2%3E1390%20Market%20Street%3C/Address2%3E%20%0A%3CUrbanization%3E%3C/Urbanization%3E%20%0A%3CCity%3EHouston%3C/City%3E%20%0A%3CState%3ETX%3C/State%3E%20%0A%3CZIP5%3E77058%3C/ZIP5%3E%20%0A%3CZIP4%3E1234%3C/ZIP4%3E%20%0A%3C/CarrierPickupAvailabilityRequest%3E%0A"
-        # expected_hash = {"CarrierPickupAvailabilityResponse"=>{"City"=>"HOUSTON", "Address2"=>"1390 Market Street", "FirmName"=>"ABC Corp.", "State"=>"TX", "Date"=>"3/1/2004", "DayOfWeek"=>"Monday", "Urbanization"=>nil, "ZIP4"=>"1234", "ZIP5"=>"77058", "CarrierRoute"=>"C", "SuiteOrApt"=>"Suite 777"}}
-        xml = REXML::Document.new(commit(:test, request, true))
-        xml.get_text('/CarrierPickupAvailabilityResponse/City').to_s == 'HOUSTON' &&
-        xml.get_text('/CarrierPickupAvailabilityResponse/Address2').to_s == '1390 Market Street'
-      end
-      
-      # options[:service] --    One of [:first_class, :priority, :express, :bpm, :parcel,
-      #                          :media, :library, :all]. defaults to :all.
-      # options[:container] --  One of [:envelope, :box]. defaults to neither (this field has
-      #                          special meaning in the USPS API).
-      # options[:books] --      Either true or false. Packages of books or other printed matter
-      #                          have a lower weight limit to be considered machinable.
-      # package.options[:machinable] -- Either true or false. Overrides the detection of
-      #                                  "machinability" entirely.
-      def build_us_rate_request(packages, origin_zip, destination_zip, options={})
-        packages = Array(packages)
-        request = XmlNode.new('RateV4Request', :USERID => @options[:login]) do |rate_request|
-          packages.each_with_index do |p,id|
-            rate_request << XmlNode.new('Package', :ID => id.to_s) do |package|
-              package << XmlNode.new('Service', US_SERVICES[options[:service] || :all])
-              package << XmlNode.new('FirstClassMailType', FIRST_CLASS_MAIL_TYPES[options[:first_class_mail_type]])
-              package << XmlNode.new('ZipOrigination', strip_zip(origin_zip))
-              package << XmlNode.new('ZipDestination', strip_zip(destination_zip))
-              package << XmlNode.new('Pounds', 0)
-              package << XmlNode.new('Ounces', "%0.1f" % [p.ounces,1].max)
-              package << XmlNode.new('Container', CONTAINERS[p.options[:container]])
-              package << XmlNode.new('Size', USPS.size_code_for(p))
-              package << XmlNode.new('Width', "%0.2f" % p.inches(:width))
-              package << XmlNode.new('Length', "%0.2f" % p.inches(:length))
-              package << XmlNode.new('Height', "%0.2f" % p.inches(:height))
-              package << XmlNode.new('Girth', "%0.2f" % p.inches(:girth))
-              is_machinable = if p.options.has_key?(:machinable)
-                p.options[:machinable] ? true : false
-              else
-                USPS.package_machinable?(p)
-              end
-              package << XmlNode.new('Machinable', is_machinable.to_s.upcase)
-            end
-          end
-        end
-        URI.encode(save_request(request.to_s))
-      end
-      
-      # important difference with international rate requests:
-      # * services are not given in the request
-      # * package sizes are not given in the request
-      # * services are returned in the response along with restrictions of size
-      # * the size restrictions are returned AS AN ENGLISH SENTENCE (!?)
-      #
-      # 
-      # package.options[:mail_type] -- one of [:package, :postcard, :matter_for_the_blind, :envelope].
-      #                                 Defaults to :package.
-      def build_world_rate_request(packages, destination)
-        country = COUNTRY_NAME_CONVERSIONS[destination.country.code(:alpha2).value] || destination.country.name
-        request = XmlNode.new('IntlRateV2Request', :USERID => @options[:login]) do |rate_request|
-          packages.each_index do |id|
-            p = packages[id]
-            rate_request << XmlNode.new('Package', :ID => id.to_s) do |package|
-              package << XmlNode.new('Pounds', 0)
-              package << XmlNode.new('Ounces', [p.ounces,1].max.ceil) #takes an integer for some reason, must be rounded UP
-              package << XmlNode.new('MailType', MAIL_TYPES[p.options[:mail_type]] || 'Package')
-              package << XmlNode.new('GXG') do |gxg|
-                gxg << XmlNode.new('POBoxFlag', destination.po_box? ? 'Y' : 'N')
-                gxg << XmlNode.new('GiftFlag', p.gift? ? 'Y' : 'N')
-              end
-              value = if p.value && p.value > 0 && p.currency && p.currency != 'USD'
-                0.0
-              else
-                (p.value || 0) / 100.0
-              end
-              package << XmlNode.new('ValueOfContents', value)
-              package << XmlNode.new('Country') do |node|
-                node.cdata = country
-              end
-              package << XmlNode.new('Container', p.cylinder? ? 'NONRECTANGULAR' : 'RECTANGULAR')
-              package << XmlNode.new('Size', USPS.size_code_for(p))
-              package << XmlNode.new('Width', "%0.2f" % [p.inches(:width), 0.01].max)
-              package << XmlNode.new('Length', "%0.2f" % [p.inches(:length), 0.01].max)
-              package << XmlNode.new('Height', "%0.2f" % [p.inches(:height), 0.01].max)
-              package << XmlNode.new('Girth', "%0.2f" % [p.inches(:girth), 0.01].max)
-            end
-          end
-        end
-        URI.encode(save_request(request.to_s))
-      end
-      
-      def parse_rate_response(origin, destination, packages, response, options={})
-        success = true
-        message = ''
-        rate_hash = {}
-        
-        xml = REXML::Document.new(response)
-        
-        if error = xml.elements['/Error']
-          success = false
-          message = error.elements['Description'].text
-        else
-          xml.elements.each('/*/Package') do |package|
-            if package.elements['Error']
-              success = false
-              message = package.get_text('Error/Description').to_s
-              break
-            end
-          end
-          
-          if success
-            rate_hash = rates_from_response_node(xml, packages)
-            unless rate_hash
-              success = false
-              message = "Unknown root node in XML response: '#{xml.root.name}'"
-            end
-          end
-          
-        end
-        
-        if success
-          rate_estimates = rate_hash.keys.map do |service_name|
-            RateEstimate.new(origin,destination,@@name,"USPS #{service_name}",
-                                      :package_rates => rate_hash[service_name][:package_rates],
-                                      :service_code => rate_hash[service_name][:service_code],
-                                      :currency => 'USD')
-          end
-          rate_estimates.reject! {|e| e.package_count != packages.length}
-          rate_estimates = rate_estimates.sort_by(&:total_price)
-        end
-        
-        RateResponse.new(success, message, Hash.from_xml(response), :rates => rate_estimates, :xml => response, :request => last_request)
-      end
-      
-      def rates_from_response_node(response_node, packages)
-        rate_hash = {}
-        return false unless (root_node = response_node.elements['/IntlRateV2Response | /RateV4Response'])
-        domestic = (root_node.name == 'RateV4Response')
-        
-        domestic_elements = ['Postage', 'CLASSID', 'MailService', 'Rate']
-        international_elements = ['Service', 'ID', 'SvcDescription', 'Postage']
-        service_node, service_code_node, service_name_node, rate_node = domestic ? domestic_elements : international_elements
-        
-        root_node.each_element('Package') do |package_node|
-          this_package = packages[package_node.attributes['ID'].to_i]
-          
-          package_node.each_element(service_node) do |service_response_node|
-            service_name = service_response_node.get_text(service_name_node).to_s
-
-            # strips the double-escaped HTML for trademark symbols from service names
-            service_name.gsub!(/&amp;lt;\S*&amp;gt;/,'')
-            # ...leading "USPS"
-            service_name.gsub!(/^USPS/,'')
-            # ...trailing asterisks
-            service_name.gsub!(/\*+$/,'')
-            # ...surrounding spaces
-            service_name.strip!
-
-            # aggregate specific package rates into a service-centric RateEstimate
-            # first package with a given service name will initialize these;
-            # later packages with same service will add to them
-            this_service = rate_hash[service_name] ||= {}
-            this_service[:service_code] ||= service_response_node.attributes[service_code_node]
-            package_rates = this_service[:package_rates] ||= []
-            this_package_rate = {:package => this_package,
-                                 :rate => Package.cents_from(service_response_node.get_text(rate_node).to_s.to_f)}
-            
-            package_rates << this_package_rate if package_valid_for_service(this_package,service_response_node)
-          end
-        end
-        rate_hash
-      end
-      
-      def package_valid_for_service(package, service_node)
-        return true if service_node.elements['MaxWeight'].nil?
-        max_weight = service_node.get_text('MaxWeight').to_s.to_f
-        name = service_node.get_text('SvcDescription | MailService').to_s.downcase
-        
-        if name =~ /flat.rate.box/ #domestic or international flat rate box
-          # flat rate dimensions from http://www.usps.com/shipping/flatrate.htm
-          return (package_valid_for_max_dimensions(package,
-                      :weight => max_weight, #domestic apparently has no weight restriction
-                      :length => 11.0,
-                      :width => 8.5,
-                      :height => 5.5) or
-                 package_valid_for_max_dimensions(package,
-                      :weight => max_weight,
-                      :length => 13.625,
-                      :width => 11.875,
-                      :height => 3.375))
-        elsif name =~ /flat.rate.envelope/
-          return package_valid_for_max_dimensions(package,
-                      :weight => max_weight,
-                      :length => 12.5,
-                      :width => 9.5,
-                      :height => 0.75)
-        elsif service_node.elements['MailService'] # domestic non-flat rates
-          return true
-        else #international non-flat rates
-          # Some sample english that this is required to parse:
-          #
-          # 'Max. length 46", width 35", height 46" and max. length plus girth 108"'
-          # 'Max. length 24", Max. length, height, depth combined 36"'
-          # 
-          sentence = CGI.unescapeHTML(service_node.get_text('MaxDimensions').to_s)
-          tokens = sentence.downcase.split(/[^\d]*"/).reject {|t| t.empty?}
-          max_dimensions = {:weight => max_weight}
-          single_axis_values = []
-          tokens.each do |token|
-            axis_sum = [/length/,/width/,/height/,/depth/].sum {|regex| (token =~ regex) ? 1 : 0}
-            unless axis_sum == 0
-              value = token[/\d+$/].to_f 
-              if axis_sum == 3
-                max_dimensions[:length_plus_width_plus_height] = value
-              elsif token =~ /girth/ and axis_sum == 1
-                max_dimensions[:length_plus_girth] = value
-              else
-                single_axis_values << value
-              end
-            end
-          end
-          single_axis_values.sort!.reverse!
-          [:length, :width, :height].each_with_index do |axis,i|
-            max_dimensions[axis] = single_axis_values[i] if single_axis_values[i]
-          end
-          return package_valid_for_max_dimensions(package, max_dimensions)
-        end
-      end
-      
-      def package_valid_for_max_dimensions(package,dimensions)
-        valid = ((not ([:length,:width,:height].map {|dim| dimensions[dim].nil? || dimensions[dim].to_f >= package.inches(dim).to_f}.include?(false))) and
-                (dimensions[:weight].nil? || dimensions[:weight] >= package.pounds) and
-                (dimensions[:length_plus_girth].nil? or
-                    dimensions[:length_plus_girth].to_f >=
-                    package.inches(:length) + package.inches(:girth)) and
-                (dimensions[:length_plus_width_plus_height].nil? or
-                    dimensions[:length_plus_width_plus_height].to_f >=
-                    package.inches(:length) + package.inches(:width) + package.inches(:height)))
-
-        return valid
-      end
-
-      def parse_tracking_response(response, options)
-        xml = REXML::Document.new(response)
-        root_node = xml.elements['TrackResponse']
-        
-        success = response_success?(xml)
-        message = response_message(xml)
-        
-        if success
-          tracking_number, origin, destination = nil
-          shipment_events = []
-          tracking_details = xml.elements.collect('*/*/TrackDetail'){ |e| e }
-          
-          tracking_summary = xml.elements.collect('*/*/TrackSummary'){ |e| e }.first
-          tracking_details << tracking_summary
-          
-          tracking_number = root_node.elements['TrackInfo'].attributes['ID'].to_s
-
-          tracking_details.each do |event|
-            location = nil
-            timestamp = nil
-            description = nil
-            if event.get_text.to_s =~ /^(.*), (\w+ \d\d, \d{4}, \d{1,2}:\d\d [ap]m), (.*), (\w\w) (\d{5})$/i ||
-                event.get_text.to_s =~ /^Your item \w{2,3} (out for delivery|delivered) at (\d{1,2}:\d\d [ap]m on \w+ \d\d, \d{4}) in (.*), (\w\w) (\d{5})\.$/i
-              description = $1.upcase
-              timestamp   = $2
-              city        = $3
-              state       = $4
-              zip_code    = $5
-              location = Location.new(:city => city, :state => state, :postal_code => zip_code, :country => 'USA')
-            end
-            if location
-              time = Time.parse(timestamp)
-              zoneless_time = Time.utc(time.year, time.month, time.mday, time.hour, time.min, time.sec)
-              shipment_events << ShipmentEvent.new(description, zoneless_time, location)
-            end
-          end
-          shipment_events = shipment_events.sort_by(&:time)
-        end
-        
-        TrackingResponse.new(success, message, Hash.from_xml(response),
-          :xml => response,
-          :request => last_request,
-          :shipment_events => shipment_events,
-          :destination => destination,
-          :tracking_number => tracking_number
-        )
-      end
-            
-      def response_status_node(document)
-        document.elements['*/*/TrackSummary'] || document.elements['Error/Description']
-      end
-      
-      def response_success?(document)
-        summary = response_status_node(document).get_text.to_s
-        !(summary =~ /There is no record of that mail item/ || summary =~ /This Information has not been included in this Test Server\./)
-      end
-      
-      def response_message(document)
-        response_node = response_status_node(document)
-        response_status_node(document).get_text.to_s
-      end
-      
-      def commit(action, request, test = false)
-        ssl_get(request_url(action, request, test))
-      end
-      
-      def request_url(action, request, test)
-        scheme = USE_SSL[action] ? 'https://' : 'http://'
-        host = test ? TEST_DOMAINS[USE_SSL[action]] : LIVE_DOMAIN
-        resource = test ? TEST_RESOURCE : LIVE_RESOURCE
-        "#{scheme}#{host}/#{resource}?API=#{API_CODES[action]}&XML=#{request}"
-      end
-      
-      def strip_zip(zip)
-        zip.to_s.scan(/\d{5}/).first || zip
-      end
-      
-    end
-  end
-end