omniship 0.1.0

data/lib/omniship/carriers/usps.rb

@@ -0,0 +1,438 @@
+# -*- encoding: utf-8 -*-
+require 'cgi'
+
+module Omniship
+  # 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'
+    }
+    USE_SSL = {
+      :us_rates => false,
+      :world_rates => false,
+      :test => true
+    }
+    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'
+    }
+    
+    # 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 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 = Address.from(origin)
+      destination = Address.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
+    
+    protected
+    
+    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('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 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

data/lib/omniship/carriers.rb

@@ -0,0 +1,13 @@
+require 'omniship/carriers/ups'
+require 'omniship/carriers/usps'
+require 'omniship/carriers/fedex'
+
+module Omniship
+  module Carriers
+    class <<self
+      def all
+        [UPS, USPS, FedEx]
+      end
+    end
+  end
+end

data/lib/omniship/contact.rb

@@ -0,0 +1,19 @@
+module Omniship
+  class Contact
+
+    attr_reader :name,
+    :attention,
+	  :account,
+	  :phone,
+	  :fax,
+	  :email
+
+    def initialize(options={})
+      @name = options[:name]
+	  	@attention = options[:attention]
+			@phone = options[:phone]
+			@fax = options[:fax]
+			@email = options[:email]
+    end
+  end
+end

data/lib/omniship/package.rb

@@ -0,0 +1,147 @@
+module Omniship #:nodoc:
+  class Package
+    include Quantified
+    
+    cattr_accessor :default_options
+    attr_reader :options,
+		            :value, 
+								:currency
+
+    # Package.new(100, [10, 20, 30], :units => :metric)
+    # Package.new(Mass.new(100, :grams), [10, 20, 30].map {|m| Length.new(m, :centimetres)})
+    # Package.new(100.grams, [10, 20, 30].map(&:centimetres))
+    def initialize(grams_or_ounces, dimensions, options = {})
+      options = @@default_options.update(options) if @@default_options
+      options.symbolize_keys!
+      @options = options
+      
+      @dimensions = [dimensions].flatten.reject {|d| d.nil?}
+      
+      imperial = (options[:units] == :imperial) ||
+        ([grams_or_ounces, *dimensions].all? {|m| m.respond_to?(:unit) && m.unit.to_sym == :imperial})
+      
+      @unit_system = imperial ? :imperial : :metric
+      
+      @weight = attribute_from_metric_or_imperial(grams_or_ounces, Mass, :grams, :ounces)
+      
+      if @dimensions.blank?
+        @dimensions = [Length.new(0, (imperial ? :inches : :centimetres))] * 3
+      else
+        process_dimensions
+      end
+      
+      @value = Package.cents_from(options[:value])
+      @currency = options[:currency] || (options[:value].currency if options[:value].respond_to?(:currency))
+      @cylinder = (options[:cylinder] || options[:tube]) ? true : false
+      @gift = options[:gift] ? true : false
+    end
+
+    def cylinder?
+      @cylinder
+    end
+    alias_method :tube?, :cylinder?
+    
+    def gift?; @gift end
+    
+    def ounces(options={})
+      weight(options).in_ounces.amount
+    end
+    alias_method :oz, :ounces
+
+    def grams(options={})
+      weight(options).in_grams.amount
+    end
+    alias_method :g, :grams
+
+    def pounds(options={})
+      weight(options).in_pounds.amount
+    end
+    alias_method :lb, :pounds
+    alias_method :lbs, :pounds
+
+    def kilograms(options={})
+      weight(options).in_kilograms.amount
+    end
+    alias_method :kg, :kilograms
+    alias_method :kgs, :kilograms
+
+    def inches(measurement=nil)
+      @inches ||= @dimensions.map {|m| m.in_inches.amount }
+      measurement.nil? ? @inches : measure(measurement, @inches)
+    end
+    alias_method :in, :inches
+
+    def centimetres(measurement=nil)
+      @centimetres ||= @dimensions.map {|m| m.in_centimetres.amount }
+      measurement.nil? ? @centimetres : measure(measurement, @centimetres)
+    end
+    alias_method :cm, :centimetres
+    
+    def weight(options = {})
+      case options[:type]
+      when nil, :actual
+        @weight
+      when :volumetric, :dimensional
+        @volumetric_weight ||= begin
+          m = Mass.new((centimetres(:box_volume) / 6.0), :grams)
+          @unit_system == :imperial ? m.in_pounds : m
+        end
+      when :billable
+        [ weight, weight(:type => :volumetric) ].max
+      end
+    end
+    alias_method :mass, :weight
+    
+    def self.cents_from(money)
+      return nil if money.nil?
+      if money.respond_to?(:cents)
+        return money.cents
+      else
+        case money
+        when Float
+          (money * 100).round
+        when String
+          money =~ /\./ ? (money.to_f * 100).round : money.to_i
+        else
+          money.to_i
+        end
+      end
+    end
+
+    private
+    
+    def attribute_from_metric_or_imperial(obj, klass, metric_unit, imperial_unit)
+      if obj.is_a?(klass)
+        return value
+      else
+        return klass.new(obj, (@unit_system == :imperial ? imperial_unit : metric_unit))
+      end
+    end
+    
+    def measure(measurement, ary)
+      case measurement
+      when Fixnum then ary[measurement] 
+      when :x, :max, :length, :long then ary[2]
+      when :y, :mid, :width, :wide then ary[1]
+      when :z, :min, :height,:depth,:high,:deep then ary[0]
+      when :girth, :around,:circumference
+        self.cylinder? ? (Math::PI * (ary[0] + ary[1]) / 2) : (2 * ary[0]) + (2 * ary[1])
+      when :volume then self.cylinder? ? (Math::PI * (ary[0] + ary[1]) / 4)**2 * ary[2] : measure(:box_volume,ary)
+      when :box_volume then ary[0] * ary[1] * ary[2]
+      end
+    end
+    
+    def process_dimensions
+      @dimensions = @dimensions.map do |l|
+        attribute_from_metric_or_imperial(l, Length, :centimetres, :inches)
+      end.sort
+      # [1,2] => [1,1,2]
+      # [5] => [5,5,5]
+      # etc..
+      2.downto(@dimensions.length) do |n|
+        @dimensions.unshift(@dimensions[0])
+      end
+    end
+
+  end
+end

data/lib/omniship/rate_estimate.rb

@@ -0,0 +1,59 @@
+module Omniship #:nodoc:
+  class RateEstimate
+    attr_reader :origin         # Location objects
+    attr_reader :destination  
+    attr_reader :package_rates  # array of hashes in the form of {:package => <Package>, :rate => 500}
+    attr_reader :carrier        # Carrier.name ('USPS', 'FedEx', etc.)
+    attr_reader :service_name   # name of service ("First Class Ground", etc.)
+    attr_reader :service_code
+    attr_reader :currency       # 'USD', 'CAD', etc.
+                                # http://en.wikipedia.org/wiki/ISO_4217
+    attr_reader :delivery_date  # Usually only available for express shipments
+    attr_reader :delivery_range # Min and max delivery estimate in days
+      
+    def initialize(origin, destination, carrier, service_name, options={})
+      @origin, @destination, @carrier, @service_name = origin, destination, carrier, service_name
+      @service_code = options[:service_code]
+      if options[:package_rates]
+        @package_rates = options[:package_rates].map {|p| p.update({:rate => Package.cents_from(p[:rate])}) }
+      else
+        @package_rates = Array(options[:packages]).map {|p| {:package => p}}
+      end
+      @total_price = Package.cents_from(options[:total_price])
+      @currency = options[:currency]
+      @delivery_range = options[:delivery_range] ? options[:delivery_range].map { |date| date_for(date) }.compact : []
+      @delivery_date = @delivery_range.last
+    end
+
+    def total_price
+      begin
+        @total_price || @package_rates.sum {|p| p[:rate]}
+      rescue NoMethodError
+        raise ArgumentError.new("RateEstimate must have a total_price set, or have a full set of valid package rates.")
+      end
+    end
+    alias_method :price, :total_price
+    
+    def add(package,rate=nil)
+      cents = Package.cents_from(rate)
+      raise ArgumentError.new("New packages must have valid rate information since this RateEstimate has no total_price set.") if cents.nil? and total_price.nil?
+      @package_rates << {:package => package, :rate => cents}
+      self
+    end
+    
+    def packages
+      package_rates.map {|p| p[:package]}
+    end
+    
+    def package_count
+      package_rates.length
+    end
+
+    private
+    def date_for(date)
+      date && DateTime.strptime(date.to_s, "%Y-%m-%d")
+    rescue ArgumentError
+      nil
+    end
+  end
+end