active_shipping 0.12.6 → 1.0.0.pre1

data/lib/active_shipping/errors.rb

@@ -0,0 +1,7 @@
+module ActiveShipping
+  class ResponseContentError < StandardError
+    def initialize(exception, content_body)
+      super("#{exception.message} \n\n#{content_body}")
+    end
+  end
+end

data/lib/active_shipping/label_response.rb

@@ -0,0 +1,23 @@
+module ActiveShipping
+  # This is UPS specific for now; the hash is not at all generic
+  # or common between carriers.
+
+  class LabelResponse < Response
+    attr :params # maybe?
+
+    def initialize(success, message, params = {}, options = {})
+      @params = params
+      super
+    end
+
+    def labels
+      return @labels if @labels
+      packages = params["ShipmentResults"]["PackageResults"]
+      packages = [packages] if Hash === packages
+      @labels  = packages.map do |package|
+        { :tracking_number => package["TrackingNumber"],
+          :image           => package["LabelImage"] }
+      end
+    end
+  end
+end

data/lib/active_shipping/location.rb

@@ -0,0 +1,149 @@
+module ActiveShipping #:nodoc:
+  class Location
+    ADDRESS_TYPES = %w(residential commercial po_box)
+
+    attr_reader :options,
+                :country,
+                :postal_code,
+                :province,
+                :city,
+                :name,
+                :address1,
+                :address2,
+                :address3,
+                :phone,
+                :fax,
+                :address_type,
+                :company_name
+
+    alias_method :zip, :postal_code
+    alias_method :postal, :postal_code
+    alias_method :state, :province
+    alias_method :territory, :province
+    alias_method :region, :province
+    alias_method :company, :company_name
+
+    def initialize(options = {})
+      @country = (options[:country].nil? or options[:country].is_a?(ActiveUtils::Country)) ?
+                    options[:country] :
+                    ActiveUtils::Country.find(options[:country])
+      @postal_code = options[:postal_code] || options[:postal] || options[:zip]
+      @province = options[:province] || options[:state] || options[:territory] || options[:region]
+      @city = options[:city]
+      @name = options[:name]
+      @address1 = options[:address1]
+      @address2 = options[:address2]
+      @address3 = options[:address3]
+      @phone = options[:phone]
+      @fax = options[:fax]
+      @company_name = options[:company_name] || options[:company]
+
+      self.address_type = options[:address_type]
+    end
+
+    def self.from(object, options = {})
+      return object if object.is_a? ActiveShipping::Location
+      attr_mappings = {
+        :name => [:name],
+        :country => [:country_code, :country],
+        :postal_code => [:postal_code, :zip, :postal],
+        :province => [:province_code, :state_code, :territory_code, :region_code, :province, :state, :territory, :region],
+        :city => [:city, :town],
+        :address1 => [:address1, :address, :street],
+        :address2 => [:address2],
+        :address3 => [:address3],
+        :phone => [:phone, :phone_number],
+        :fax => [:fax, :fax_number],
+        :address_type => [:address_type],
+        :company_name => [:company, :company_name]
+      }
+      attributes = {}
+      hash_access = begin
+        object[:some_symbol]
+        true
+      rescue
+        false
+      end
+      attr_mappings.each do |pair|
+        pair[1].each do |sym|
+          if value = (object[sym] if hash_access) || (object.send(sym) if object.respond_to?(sym) && (!hash_access || !Hash.public_instance_methods.include?(sym.to_s)))
+            attributes[pair[0]] = value
+            break
+          end
+        end
+      end
+      attributes.delete(:address_type) unless ADDRESS_TYPES.include?(attributes[:address_type].to_s)
+      new(attributes.update(options))
+    end
+
+    def country_code(format = :alpha2)
+      @country.nil? ? nil : @country.code(format).value
+    end
+
+    def residential?; @address_type == 'residential' end
+    def commercial?; @address_type == 'commercial' end
+    def po_box?; @address_type == 'po_box' end
+    def unknown?; country_code == 'ZZ' end
+
+    def address_type=(value)
+      return unless value.present?
+      raise ArgumentError.new("address_type must be one of #{ADDRESS_TYPES.join(', ')}") unless ADDRESS_TYPES.include?(value.to_s)
+      @address_type = value.to_s
+    end
+
+    def to_hash
+      {
+        :country => country_code,
+        :postal_code => postal_code,
+        :province => province,
+        :city => city,
+        :name => name,
+        :address1 => address1,
+        :address2 => address2,
+        :address3 => address3,
+        :phone => phone,
+        :fax => fax,
+        :address_type => address_type,
+        :company_name => company_name
+      }
+    end
+
+    def to_xml(options = {})
+      options[:root] ||= "location"
+      to_hash.to_xml(options)
+    end
+
+    def to_s
+      prettyprint.gsub(/\n/, ' ')
+    end
+
+    def prettyprint
+      chunks = [@name, @address1, @address2, @address3]
+      chunks << [@city, @province, @postal_code].reject(&:blank?).join(', ')
+      chunks << @country
+      chunks.reject(&:blank?).join("\n")
+    end
+
+    def inspect
+      string = prettyprint
+      string << "\nPhone: #{@phone}" unless @phone.blank?
+      string << "\nFax: #{@fax}" unless @fax.blank?
+      string
+    end
+
+    # Returns the postal code as a properly formatted Zip+4 code, e.g. "77095-2233"
+    def zip_plus_4
+      if /(\d{5})(\d{4})/ =~ @postal_code
+        return "#{$1}-#{$2}"
+      elsif /\d{5}-\d{4}/ =~ @postal_code
+        return @postal_code
+      else
+        nil
+      end
+    end
+
+    def address2_and_3
+      [address2, address3].reject(&:blank?).join(", ")
+    end
+  end
+end

data/lib/active_shipping/package.rb

@@ -0,0 +1,241 @@
+module ActiveShipping #:nodoc:
+  # A package item is a unique item(s) that is physically in a package.
+  # A single package can have many items. This is only required
+  # for shipping methods (label creation) right now.
+  class PackageItem
+    include Quantified
+
+    attr_reader :sku, :hs_code, :value, :name, :weight, :quantity, :options
+
+    def initialize(name, grams_or_ounces, value, quantity, options = {})
+      @name = name
+
+      imperial = (options[:units] == :imperial) ||
+                 (grams_or_ounces.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)
+
+      @value = Package.cents_from(value)
+      @quantity = quantity > 0 ? quantity : 1
+
+      @sku = options[:sku]
+      @hs_code = options[:hs_code]
+      @options = options
+    end
+
+    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_ounces : m
+        end
+      when :billable
+        [weight, weight(:type => :volumetric)].max
+      end
+    end
+    alias_method :mass, :weight
+
+    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
+
+    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
+  end
+
+  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(&:nil?)
+
+      imperial = (options[:units] == :imperial) ||
+                 ([grams_or_ounces, *dimensions].all? { |m| m.respond_to?(:unit) && m.unit.to_sym == :imperial })
+
+      weight_imperial = dimensions_imperial = imperial if options.include?(:units)
+
+      if options.include?(:weight_units)
+        weight_imperial = (options[:weight_units] == :imperial) ||
+                          (grams_or_ounces.respond_to?(:unit) && m.unit.to_sym == :imperial)
+      end
+
+      if options.include?(:dim_units)
+        dimensions_imperial = (options[:dim_units] == :imperial) ||
+                              (dimensions && dimensions.all? { |m| m.respond_to?(:unit) && m.unit.to_sym == :imperial })
+      end
+
+      @weight_unit_system = weight_imperial ? :imperial : :metric
+      @dimensions_unit_system = dimensions_imperial ? :imperial : :metric
+
+      @weight = attribute_from_metric_or_imperial(grams_or_ounces, Mass, @weight_unit_system, :grams, :ounces)
+
+      if @dimensions.blank?
+        @dimensions = [Length.new(0, (dimensions_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
+      @oversized = options[:oversized] ? true : false
+      @unpackaged = options[:unpackaged] ? true : false
+    end
+
+    def unpackaged?
+      @unpackaged
+    end
+
+    def oversized?
+      @oversized
+    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)
+          @weight_unit_system == :imperial ? m.in_ounces : 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, unit_system, metric_unit, imperial_unit)
+      if obj.is_a?(klass)
+        return obj
+      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, @dimensions_unit_system, :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/active_shipping/rate_estimate.rb

@@ -0,0 +1,64 @@
+module ActiveShipping #: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 :shipping_date
+    attr_reader :delivery_date  # Usually only available for express shipments
+    attr_reader :delivery_range # Min and max delivery estimate in days
+    attr_reader :negotiated_rate
+    attr_reader :insurance_price
+
+    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])
+      @negotiated_rate = options[:negotiated_rate] ? Package.cents_from(options[:negotiated_rate]) : nil
+      @currency = ActiveUtils::CurrencyCode.standardize(options[:currency])
+      @delivery_range = options[:delivery_range] ? options[:delivery_range].map { |date| date_for(date) }.compact : []
+      @shipping_date = date_for(options[:shipping_date])
+      @delivery_date = @delivery_range.last
+      @insurance_price = Package.cents_from(options[:insurance_price])
+    end
+
+    def total_price
+      @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
+    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