active_shipping 0.12.6 → 1.0.0.pre1

data/lib/active_shipping/shipping/errors.rb

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

data/lib/active_shipping/shipping/label_response.rb

@@ -1,25 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Shipping
-    # 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
-end

data/lib/active_shipping/shipping/location.rb

@@ -1,152 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Shipping #: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?(ActiveMerchant::Country)) ?
-                      options[:country] :
-                      ActiveMerchant::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? ActiveMerchant::Shipping::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 = []
-        chunks << [@name, @address1, @address2, @address3].reject(&:blank?).join("\n")
-        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
-end

data/lib/active_shipping/shipping/package.rb

@@ -1,243 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Shipping #: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
-end

data/lib/active_shipping/shipping/rate_estimate.rb

@@ -1,66 +0,0 @@
-module ActiveMerchant #:nodoc:
-  module Shipping #: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 = ActiveMerchant::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
-end