active_shipping 0.12.4 → 0.12.5

data/lib/active_shipping/shipping/response.rb

@@ -1,13 +1,11 @@
 module ActiveMerchant #:nodoc:
-    
   module Shipping #:nodoc:
-    
     class Error < ActiveMerchant::ActiveMerchantError
     end
-    
+
     class ResponseError < Error
       attr_reader :response
-      
+
       def initialize(response = nil)
         if response.is_a? Response
           super(response.message)
@@ -15,17 +13,16 @@ module ActiveMerchant #:nodoc:
         else
           super(response)
         end
-      end      
+      end
     end
-    
+
     class Response
-      
       attr_reader :params
       attr_reader :message
       attr_reader :test
       attr_reader :xml
       attr_reader :request
-        
+
       def initialize(success, message, params = {}, options = {})
         @success, @message, @params = success, message, params.stringify_keys
         @test = options[:test] || false
@@ -33,7 +30,7 @@ module ActiveMerchant #:nodoc:
         @request = options[:request]
         raise ResponseError.new(self) unless success
       end
-    
+
       def success?
         @success ? true : false
       end

data/lib/active_shipping/shipping/shipment_event.rb

@@ -1,10 +1,9 @@
 module ActiveMerchant #:nodoc:
   module Shipping
-      
     class ShipmentEvent
       attr_reader :name, :time, :location, :message
-      
-      def initialize(name, time, location, message=nil)
+
+      def initialize(name, time, location, message = nil)
         @name, @time, @location, @message = name, time, location, message
       end
 
@@ -16,6 +15,5 @@ module ActiveMerchant #:nodoc:
         @status ||= name.downcase.gsub("\s", "_").to_sym
       end
     end
-    
   end
 end

data/lib/active_shipping/shipping/shipment_packer.rb

@@ -13,40 +13,55 @@ module ActiveMerchant
       # maximum_weight  - maximum weight in grams
       # currency        - ISO currency code
       def self.pack(items, dimensions, maximum_weight, currency)
+        return [] if items.empty?
         packages = []
 
-        return packages if items.empty?
+        # Naive in that it assumes weight is equally distributed across all items
+        # Should raise early enough in most cases
+        total_weight = 0
+        items.map!(&:symbolize_keys).each do |item|
+          total_weight += item[:quantity].to_i * item[:grams].to_i
 
-        items.map!(&:symbolize_keys)
+          if item[:grams].to_i > maximum_weight
+            raise OverweightItem, "The item with weight of #{item[:grams]}g is heavier than the allowable package weight of #{maximum_weight}g"
+          end
 
-        if items.sum { |item| item[:quantity].to_i } >= EXCESS_PACKAGE_QUANTITY_THRESHOLD
-          raise ExcessPackageQuantity, "Unable to pack more than #{EXCESS_PACKAGE_QUANTITY_THRESHOLD} packages"
+          if total_weight > maximum_weight * EXCESS_PACKAGE_QUANTITY_THRESHOLD
+            raise ExcessPackageQuantity, "Unable to pack more than #{EXCESS_PACKAGE_QUANTITY_THRESHOLD} packages"
+          end
         end
 
-        items = items.map { |item| [item] * item[:quantity].to_i }.flatten
-        state = :package_empty
+        items = items.deep_dup.sort_by! { |i| i[:grams].to_i }
 
+        state = :package_empty
         while state != :packing_finished
           case state
           when :package_empty
             package_weight, package_value = 0, 0
             state = :filling_package
           when :filling_package
-            item = items.shift
-            item_weight, item_price = item[:grams].to_i, Package.cents_from(item[:price])
+            items.each do |item|
+              quantity = if item[:grams].to_i <= 0
+                item[:quantity].to_i
+              else
+                # Grab the max amount of this item we can fit into this package
+                # Or, if there are fewer than the max for this item, put
+                # what is left into this package
+                [(maximum_weight - package_weight) / item[:grams].to_i, item[:quantity].to_i].min
+              end
 
-            if item_weight > maximum_weight
-              raise OverweightItem, "The item with weight of #{item_weight}g is heavier than the allowable package weight of #{maximum_weight}g"
-            end
+              item_weight = quantity * item[:grams].to_i
+              item_value = quantity * Package.cents_from(item[:price])
 
-            if (package_weight + item_weight) <= maximum_weight
               package_weight += item_weight
-              package_value  += item_price
-              state = :package_full if items.empty?
-            else
-              items.unshift(item)
-              state = :package_full
+              package_value += item_value
+
+              item[:quantity] = item[:quantity].to_i - quantity
             end
+
+            items.reject! { |i| i[:quantity].to_i == 0 }
+
+            state = :package_full
           when :package_full
             packages << ActiveMerchant::Shipping::Package.new(package_weight, dimensions, :value => package_value, :currency => currency)
             state = items.any? ? :package_empty : :packing_finished

data/lib/active_shipping/shipping/shipping_response.rb

@@ -1,16 +1,14 @@
 module ActiveMerchant #:nodoc:
   module Shipping
-    
     class ShippingResponse < Response
       attr_reader :shipping_id # string
       attr_reader :tracking_number # string
-      
+
       def initialize(success, message, params = {}, options = {})
         @shipping_id = options[:shipping_id]
         @tracking_number = options[:tracking_number]
         super
       end
     end
-    
   end
-end
+end

data/lib/active_shipping/shipping/tracking_response.rb

@@ -1,20 +1,19 @@
 module ActiveMerchant #:nodoc:
   module Shipping
-    
     class TrackingResponse < Response
       attr_reader :carrier # symbol
       attr_reader :carrier_name # string
       attr_reader :status # symbol
       attr_reader :status_code # string
-      attr_reader :status_description #string
+      attr_reader :status_description # string
       attr_reader :ship_time # time
       attr_reader :scheduled_delivery_date # time
       attr_reader :actual_delivery_date # time
-      attr_reader :delivery_signature #string
+      attr_reader :delivery_signature # string
       attr_reader :tracking_number # string
       attr_reader :shipment_events # array of ShipmentEvents in chronological order
       attr_reader :shipper_address, :origin, :destination # Location objects
-      
+
       def initialize(success, message, params = {}, options = {})
         @carrier = options[:carrier].parameterize.to_sym
         @carrier_name = options[:carrier]
@@ -51,6 +50,5 @@ module ActiveMerchant #:nodoc:
       alias_method(:scheduled_delivery_time, :scheduled_delivery_date)
       alias_method(:actual_delivery_time, :actual_delivery_date)
     end
-    
   end
 end

data/lib/active_shipping/version.rb

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

data/lib/vendor/quantified/lib/quantified/attribute.rb

@@ -1,206 +1,205 @@
 module Quantified
   class Attribute
     include Comparable
-    
+
     attr_reader :amount, :unit
-    
+
     def initialize(amount, unit)
       raise ArgumentError, "amount must be a Numeric" unless amount.is_a?(Numeric)
       @amount, @unit = amount, unit.to_sym
     end
-    
+
     def to_s
       "#{amount} #{unit}"
     end
-    
+
     def inspect
       "#<#{self.class.name}: #{amount} #{unit}>"
     end
-    
+
     def ==(other)
-      (BigDecimal.new(self.amount.to_s) == BigDecimal.new(other.amount.to_s) && self.unit == other.unit) || BigDecimal.new(self.class.convert(self.amount, self.unit, other.unit).to_s) == BigDecimal.new(other.amount.to_s)
+      (BigDecimal.new(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit) || BigDecimal.new(self.class.convert(amount, unit, other.unit).to_s) == BigDecimal.new(other.amount.to_s)
     rescue NoMethodError
-      self.amount == other
+      amount == other
     end
-    
+
     def eql?(other)
-      self.class == other.class && BigDecimal.new(self.amount.to_s) == BigDecimal.new(other.amount.to_s) && self.unit == other.unit
+      self.class == other.class && BigDecimal.new(amount.to_s) == BigDecimal.new(other.amount.to_s) && unit == other.unit
     end
-    
+
     def <=>(other)
       if self.class == other.class
-        self.class.convert(self.amount, self.unit, other.unit) <=> other.amount
+        self.class.convert(amount, unit, other.unit) <=> other.amount
       else
-        self.amount <=> other
+        amount <=> other
       end
     end
-    
+
     def system
       self.class.units_to_systems[unit]
     end
 
     def coerce(other)
-      [other, self.amount]
+      [other, amount]
     end
-    
+
     def method_missing(meth, *args)
       if args.size == 1 && self.class == (other = args.first).class
-        other_amount_in_self_units = self.class.convert(other.amount, other.unit, self.unit)
-        self.class.new(amount.send(meth, other_amount_in_self_units), self.unit)
+        other_amount_in_self_units = self.class.convert(other.amount, other.unit, unit)
+        self.class.new(amount.send(meth, other_amount_in_self_units), unit)
       else
         amount.send(meth, *args)
       end
     end
-    
+
     def self.conversion_rate(from, to)
-      return nil unless self.conversions[from] and self.conversions[to]
-      return self.conversions[from][to] ||=
-      (1.0 / self.conversions[to][from] if self.conversions[to][from]) || begin
-        shared_conversions = self.conversions[from].keys & self.conversions[to].keys
+      return nil unless conversions[from] and conversions[to]
+      conversions[from][to] ||=
+      (1.0 / conversions[to][from] if conversions[to][from]) || begin
+        shared_conversions = conversions[from].keys & conversions[to].keys
         if shared_conversions.any?
           primitive = shared_conversions.first
-          self.conversions[from][primitive] * (1.0 / self.conversions[to][primitive])
+          conversions[from][primitive] * (1.0 / conversions[to][primitive])
         else
-          self.conversions[from].each do |conversion_unit, multiple|
-            if self.conversions[to].include?(conversion_unit)
-              return multiple * conversion_rate(conversion) * (1.0 / self.conversions[to][conversion_unit])
+          conversions[from].each do |conversion_unit, multiple|
+            if conversions[to].include?(conversion_unit)
+              return multiple * conversion_rate(conversion) * (1.0 / conversions[to][conversion_unit])
             end
           end
-          from_primitive = (self.conversions[from].keys & self.primitives).first
-          to_primitive = (self.conversions[to].keys & self.primitives).first
+          from_primitive = (conversions[from].keys & primitives).first
+          to_primitive = (conversions[to].keys & primitives).first
           if from_primitive_to_primitive_multiple = conversion_rate(from_primitive, to_primitive)
-            return self.conversions[from][from_primitive] * from_primitive_to_primitive_multiple * (1.0 / self.conversions[to][to_primitive])
+            return conversions[from][from_primitive] * from_primitive_to_primitive_multiple * (1.0 / conversions[to][to_primitive])
           end
           raise StandardError, "No conversion path from #{from} to #{to}"
         end
       end
     end
-    
-    def self.units(system=nil)
+
+    def self.units(system = nil)
       if system
-        self.systems_to_units[system.to_sym].dup
+        systems_to_units[system.to_sym].dup
       else
-        self.primitives | self.conversions.keys
+        primitives | conversions.keys
       end
     end
-    
+
     def self.non_primitives
-      self.conversions.keys
+      conversions.keys
     end
-    
+
     def self.systems
-      self.systems_to_units.keys
+      systems_to_units.keys
     end
-    
+
     def self.add_numeric_methods?
-      self.add_numeric_methods
+      add_numeric_methods
     end
-    
+
     def self.numeric_methods(*args)
       args.each do |arg|
         add_numeric_method_for(arg.to_sym)
       end
     end
-    
+
     protected
 
     class << self
       def primitives;              @primitives ||= [];             end
       def add_numeric_methods;     @add_numeric_methods ||= false; end
-      def add_numeric_methods=(v); @add_numeric_methods = v;       end
+      attr_writer :add_numeric_methods
       def conversions;             @conversions ||= {};            end
-      def current_system;          @current_system;                end
-      def current_system=(v);      @current_system = v;            end
+      attr_reader :current_system
+      attr_writer :current_system
       def systems_to_units;        @systems_to_units ||= {};       end
       def units_to_systems;        @units_to_systems ||= {};       end
     end
 
-    
     def self.system(system_name, &block)
-      old_system = self.current_system
+      old_system = current_system
       self.current_system = system_name.to_sym
       yield
       self.current_system = old_system
     end
-    
-    def self.primitive(sym, options={})
+
+    def self.primitive(sym, options = {})
       unit_sym = (options[:plural] || sym.to_s.pluralize).to_sym
-      self.primitives << unit_sym
+      primitives << unit_sym
       add_to_system(unit_sym)
       add_methods_for(unit_sym, options)
     end
-    
+
     def self.add_to_system(unit_sym)
-      if self.current_system
-        self.units_to_systems[unit_sym] ||= begin
-          sys_ary = self.systems_to_units[self.current_system] ||= []
+      if current_system
+        units_to_systems[unit_sym] ||= begin
+          sys_ary = systems_to_units[current_system] ||= []
           sys_ary << unit_sym
-          self.current_system
+          current_system
         end
       end
     end
-    
-    def self.one(sym, options={})
+
+    def self.one(sym, options = {})
       unit_sym = (options[:plural] || sym.to_s.pluralize).to_sym
       add_to_system(unit_sym)
       register_unit(unit_sym, options[:is].unit, options[:is].amount)
       add_methods_for(unit_sym, options)
     end
-    
+
     def self.register_unit(multiple_unit, other_unit, multiple)
       multiple_unit, other_unit = multiple_unit.to_sym, other_unit.to_sym
-      self.conversions[multiple_unit] ||= {}
-      self.conversions[other_unit] ||= {}
-      
-      if self.primitives.include?(multiple_unit) || self.primitives.include?(other_unit)
+      conversions[multiple_unit] ||= {}
+      conversions[other_unit] ||= {}
+
+      if primitives.include?(multiple_unit) || primitives.include?(other_unit)
         add_conversion(multiple_unit, other_unit, multiple)
       else
         [multiple_unit, other_unit].each do |this_unit|
-          self.conversions[this_unit].each do |this_other_unit, this_multiple|
-            if self.primitives.include?(this_other_unit)
+          conversions[this_unit].each do |this_other_unit, this_multiple|
+            if primitives.include?(this_other_unit)
               add_conversion(multiple_unit, this_other_unit, multiple * this_multiple)
             end
           end
         end
       end
     end
-    
+
     def self.add_conversion(multiple_unit, other_unit, multiple)
-      self.conversions[multiple_unit] ||={}
-      self.conversions[multiple_unit][other_unit] = multiple
-      self.conversions[other_unit] ||= {}
-      self.conversions[other_unit][multiple_unit] = (1.0 / multiple)
+      conversions[multiple_unit] ||= {}
+      conversions[multiple_unit][other_unit] = multiple
+      conversions[other_unit] ||= {}
+      conversions[other_unit][multiple_unit] = (1.0 / multiple)
     end
-    
+
     def self.convert(amount, from, to)
       from, to = from.to_sym, to.to_sym
       amount * conversion_rate(from, to)
     end
-    
-    def self.add_methods_for(sym, options={})
+
+    def self.add_methods_for(sym, options = {})
       add_conversion_method_for(sym, options)
       add_numeric_method = if options.has_key?(:add_numeric_methods)
         options[:add_numeric_methods]
       else
-        self.add_numeric_methods
+        add_numeric_methods
       end
       add_numeric_method_for(sym.to_s, options) if add_numeric_method
     end
-    
-    def self.add_conversion_method_for(sym, options={})
+
+    def self.add_conversion_method_for(sym, options = {})
       unit_name = sym.to_s
       class_eval do
         define_method("to_#{unit_name}") do
-          return self if unit_name == self.unit.to_s
-          self.class.new(self.class.convert(self.amount, self.unit, unit_name), unit_name)
+          return self if unit_name == unit.to_s
+          self.class.new(self.class.convert(amount, unit, unit_name), unit_name)
         end
-        alias_method("in_#{unit_name}","to_#{unit_name}")
+        alias_method("in_#{unit_name}", "to_#{unit_name}")
       end
     end
-    
-    def self.add_numeric_method_for(unit_name, options={})
+
+    def self.add_numeric_method_for(unit_name, options = {})
       unit_name = unit_name.to_sym
-      raise ArgumentError, "#{unit_name.inspect} is not a unit in #{self.name}" unless units.include?(unit_name)
+      raise ArgumentError, "#{unit_name.inspect} is not a unit in #{name}" unless units.include?(unit_name)
       klass = self
       Numeric.class_eval do
         define_method(unit_name) do