spree_core 3.2.9 → 3.3.0.rc1

data/app/models/spree/shipment_handler.rb

@@ -20,9 +20,9 @@ module Spree
     def perform
       @shipment.inventory_units.each &:ship!
       @shipment.process_order_payments if Spree::Config[:auto_capture_on_dispatch]
+      send_shipped_email
       @shipment.touch :shipped_at
       update_order_shipment_state
-      send_shipped_email
     end
 
     private

data/app/models/spree/shipping_category.rb

@@ -1,6 +1,6 @@
 module Spree
   class ShippingCategory < Spree::Base
-    validates :name, presence: true, uniqueness: { allow_blank: true }
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     with_options inverse_of: :shipping_category do
       has_many :products

data/app/models/spree/shipping_method.rb

@@ -5,7 +5,6 @@ module Spree
     DISPLAY = [:both, :front_end, :back_end]
 
     # Used for #refresh_rates
-    DISPLAY_ON_FRONT_AND_BACK_END = 0
     DISPLAY_ON_FRONT_END = 1
     DISPLAY_ON_BACK_END = 2
 
@@ -20,7 +19,7 @@ module Spree
                                      foreign_key: 'shipping_method_id'
     has_many :zones, through: :shipping_method_zones, class_name: 'Spree::Zone'
 
-    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
 
     validates :name, presence: true
 
@@ -43,23 +42,26 @@ module Spree
         .select { |c| c.to_s.constantize < Spree::ShippingCalculator }
     end
 
-    # Some shipping methods are only meant to be set via backend
-    def frontend?
-      self.display_on != "back_end"
-    end
-
     def tax_category
       Spree::TaxCategory.unscoped { super }
     end
 
-    def available_to_display(display_filter)
-      display_filter == DISPLAY_ON_FRONT_AND_BACK_END ||
+    def available_to_display?(display_filter)
       (frontend? && display_filter == DISPLAY_ON_FRONT_END) ||
-      (!frontend? && display_filter == DISPLAY_ON_BACK_END)
+      (backend? && display_filter == DISPLAY_ON_BACK_END)
     end
 
     private
 
+    # Some shipping methods are only meant to be set via backend
+    def frontend?
+      display_on.in?(['both', 'front_end'])
+    end
+
+    def backend?
+      display_on.in?(['both', 'back_end'])
+    end
+
     def at_least_one_shipping_category
       if shipping_categories.empty?
         errors.add(:base, :required_shipping_category)

data/app/models/spree/state_change.rb

@@ -1,6 +1,6 @@
 module Spree
   class StateChange < Spree::Base
-    belongs_to :user, class_name: Spree.user_class
+    belongs_to :user, class_name: Spree.user_class.to_s, optional: true
     belongs_to :stateful, polymorphic: true
 
     def <=>(other)

data/app/models/spree/stock/adjuster.rb

@@ -3,31 +3,52 @@
 module Spree
   module Stock
     class Adjuster
-      attr_accessor :inventory_unit, :status, :fulfilled, :package
+      attr_accessor :required_quantity, :received_quantity, :backorder_package,
+                    :backorder_item
 
-      def initialize(inventory_unit, status, package=nil)
-        @inventory_unit = inventory_unit
-        @status = status
-        @package = package
-        @fulfilled = false
+      def initialize(inventory_unit)
+        self.required_quantity = inventory_unit.required_quantity
+        self.backorder_package = nil
+        self.backorder_item = nil
+        self.received_quantity = 0
       end
 
-      def adjust(package)
+      def adjust(package_to_adjust, item)
         if fulfilled?
-          package.remove(inventory_unit)
+          package_to_adjust.remove_item item
+        elsif item.backordered?
+          # We only use the first backorder item to fill backorders
+          # as the items/packages are processed in priority order
+          if backorder_package.nil?
+            self.backorder_package = package_to_adjust
+            self.backorder_item = item
+          else
+            package_to_adjust.remove_item item
+          end
         else
-          self.fulfilled = true
+          if item.quantity >= remaining_quantity
+            item.quantity = remaining_quantity
+          end
+          self.received_quantity += item.quantity
+          update_backorder
         end
       end
 
-      def reassign(status, package)
-        @fulfilled = false
-        @status = status
-        @package = package
+      def update_backorder
+        return if backorder_package.nil?
+        if fulfilled?
+          backorder_package.remove_item backorder_item
+        elsif backorder_item.present?
+          backorder_item.quantity = remaining_quantity
+        end
       end
 
       def fulfilled?
-        fulfilled
+        remaining_quantity.zero?
+      end
+
+      def remaining_quantity
+        required_quantity - received_quantity
       end
     end
   end

data/app/models/spree/stock/availability_validator.rb

@@ -2,7 +2,7 @@ module Spree
   module Stock
     class AvailabilityValidator < ActiveModel::Validator
       def validate(line_item)
-        unit_count = line_item.inventory_units.size
+        unit_count = line_item.inventory_units.sum(&:quantity)
         return if unit_count >= line_item.quantity
 
         quantity = line_item.quantity - unit_count

data/app/models/spree/stock/content_item.rb

@@ -10,6 +10,7 @@ module Spree
 
       with_options allow_nil: true do
         delegate :line_item,
+                 :quantity,
                  :variant, to: :inventory_unit
         delegate :price, to: :variant
         delegate :dimension,
@@ -17,10 +18,18 @@ module Spree
                  :weight, to: :variant, prefix: true
       end
 
+      def splittable_by_weight?
+        quantity > 1 && variant_weight.present?
+      end
+
       def weight
         variant_weight * quantity
       end
 
+      def quantity=(value)
+        @inventory_unit.quantity = value
+      end
+
       def on_hand?
         state.to_s == "on_hand"
       end
@@ -34,14 +43,6 @@ module Spree
         price * quantity
       end
 
-      def quantity
-        # Since inventory units don't have a quantity,
-        # make this always 1 for now, leaving ourselves
-        # open to a different possibility in the future,
-        # but this massively simplifies things for now
-        1
-      end
-
       def volume
         variant_volume * quantity
       end

data/app/models/spree/stock/coordinator.rb

@@ -1,12 +1,12 @@
 module Spree
   module Stock
     class Coordinator
-      attr_reader :order, :inventory_units, :allocated_inventory_units
+      attr_reader   :order, :inventory_units
+      attr_accessor :unallocated_inventory_units
 
       def initialize(order, inventory_units = nil)
         @order = order
         @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
-        @allocated_inventory_units = []
       end
 
       def shipments
@@ -23,20 +23,14 @@ module Spree
 
       def build_packages(packages = Array.new)
         stock_locations_with_requested_variants.each do |stock_location|
-          packer = build_packer(stock_location, unallocated_inventory_units)
+          packer = build_packer(stock_location, inventory_units)
           packages += packer.packages
-          @allocated_inventory_units += packer.allocated_inventory_units
         end
 
         packages
       end
 
       private
-
-      def unallocated_inventory_units
-        inventory_units - allocated_inventory_units
-      end
-
       def stock_locations_with_requested_variants
         Spree::StockLocation.active.joins(:stock_items).
           where(spree_stock_items: { variant_id: requested_variant_ids }).distinct

data/app/models/spree/stock/estimator.rb

@@ -58,7 +58,7 @@ module Spree
         package.shipping_methods.select do |ship_method|
           calculator = ship_method.calculator
 
-          ship_method.available_to_display(display_filter) &&
+          ship_method.available_to_display?(display_filter) &&
           ship_method.include?(order.ship_address) &&
           calculator.available?(package) &&
           (calculator.preferences[:currency].blank? ||

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -6,15 +6,16 @@ module Spree
       end
 
       def units
-        @order.line_items.flat_map do |line_item|
-          line_item.quantity.times.map do |i|
-            @order.inventory_units.build(
-              pending: true,
-              variant_id: line_item.variant_id,
-              line_item: line_item,
-              order: @order
-            )
-          end
+        @order.line_items.map do |line_item|
+          # They go through multiple splits, avoid loading the
+          # association to order until needed.
+          InventoryUnit.new(
+            pending:    true,
+            line_item:  line_item,
+            variant:    line_item.variant,
+            quantity:   line_item.quantity,
+            order_id:   @order.id
+          )
         end
       end
     end

data/app/models/spree/stock/package.rb

@@ -21,7 +21,11 @@ module Spree
 
       def remove(inventory_unit)
         item = find_item(inventory_unit)
-        @contents -= [item] if item
+        remove_item(item) if item
+      end
+
+      def remove_item(item)
+        @contents -= [item]
       end
 
       # Fix regression that removed package.order.
@@ -55,7 +59,7 @@ module Spree
       end
 
       def empty?
-        quantity == 0
+        quantity.zero?
       end
 
       def currency
@@ -90,10 +94,6 @@ module Spree
         )
       end
 
-      def contents_by_weight
-        contents.sort { |x, y| y.weight <=> x.weight }
-      end
-
       def volume
         contents.sum(&:volume)
       end

data/app/models/spree/stock/packer.rb

@@ -1,13 +1,12 @@
 module Spree
   module Stock
     class Packer
-      attr_reader :stock_location, :inventory_units, :splitters, :allocated_inventory_units
+      attr_reader :stock_location, :inventory_units, :splitters
 
       def initialize(stock_location, inventory_units, splitters=[Splitter::Base])
         @stock_location = stock_location
         @inventory_units = inventory_units
         @splitters = splitters
-        @allocated_inventory_units = []
       end
 
       def packages
@@ -22,22 +21,16 @@ module Spree
         package = Package.new(stock_location)
 
         # Group by variant_id as grouping by variant fires cached query.
-        inventory_units.group_by(&:variant_id).each do |variant_id, variant_inventory_units|
+        inventory_units.index_by(&:variant_id).each do |variant_id, inventory_unit|
           variant = Spree::Variant.find(variant_id)
-          units = variant_inventory_units.clone
+          unit = inventory_unit.dup # Can be used by others, do not use directly
           if variant.should_track_inventory?
-            next unless stock_location.stock_item(variant)
-
-            on_hand, backordered = stock_location.fill_status(variant, units.size)
-            on_hand_units, backordered_units = units.slice!(0, on_hand), units.slice!(0, backordered)
-
-            package.add_multiple on_hand_units, :on_hand if on_hand > 0
-            package.add_multiple backordered_units, :backordered if backordered > 0
-
-            @allocated_inventory_units += (on_hand_units + backordered_units)
+            next unless stock_location.stocks? variant
+            on_hand, backordered = stock_location.fill_status(variant, unit.quantity)
+            package.add(InventoryUnit.split(unit, backordered), :backordered) if backordered.positive?
+            package.add(InventoryUnit.split(unit, on_hand), :on_hand) if on_hand.positive?
           else
-            package.add_multiple units
-            @allocated_inventory_units += units
+            package.add unit
           end
         end
 

data/app/models/spree/stock/prioritizer.rb

@@ -22,27 +22,20 @@ module Spree
         packages.each do |package|
           package.contents.each do |item|
             adjuster = find_adjuster(item)
-
             if adjuster.nil?
               adjuster = build_adjuster(item, package)
-            elsif item.state == :on_hand && adjuster.status == :backordered
-              # Remove item from backordered package
-              adjuster.package.remove(item.inventory_unit)
-              # Reassign adjuster's status package
-              adjuster.reassign(:on_hand, package)
             end
-
-            adjuster.adjust(package)
+            adjuster.adjust(package, item)
           end
         end
       end
 
       def build_adjuster(item, package)
-        @adjusters[item.inventory_unit] = @adjuster_class.new(item.inventory_unit, item.state, package)
+        @adjusters[hash_item item] = @adjuster_class.new(item.inventory_unit)
       end
 
       def find_adjuster(item)
-        @adjusters[item.inventory_unit]
+        @adjusters[hash_item item]
       end
 
       def sort_packages
@@ -52,6 +45,16 @@ module Spree
       def prune_packages
         packages.reject! { |pkg| pkg.empty? }
       end
+
+      def hash_item(item)
+        shipment = item.inventory_unit.shipment
+        variant  = item.inventory_unit.variant
+        if shipment.present?
+          variant.hash ^ shipment.hash
+        else
+          variant.hash
+        end
+      end
     end
   end
 end

data/app/models/spree/stock/splitter/weight.rb

@@ -9,26 +9,78 @@ module Spree
         end
 
         def split(packages)
+          generated_packages = []
           packages.each do |package|
-            removed_contents = reduce package
-            packages << build_package(removed_contents) unless removed_contents.empty?
+            generated_packages.push *reduce(package)
           end
+          packages.push *generated_packages
           return_next packages
         end
 
         private
+
         def reduce(package)
-          removed = []
-          while package.weight > self.threshold
-            contents = package.contents_by_weight
-            break if contents.size == 1
-            # Deleting the second heaviest item in the package should yield best results
-            removed << package.contents.delete(contents[1])
+          contents = split_package_contents_over_threshold(package).sort { |x, y| y.weight <=> x.weight }
+          # Treat current package as one of the generated packages for convenience and add the heaviest item
+          # This also prevents an additional package if no fit is possible
+          package.contents.clear
+          package.contents << contents.shift
+          _split_packages = [package]
+          while contents.present?
+
+            package_to_use = choose_package _split_packages, contents.first
+
+            if package_to_use.nil?
+              package_to_use = build_package
+              _split_packages << package_to_use
+            end
+
+            package_to_use.contents << contents.shift
           end
-          removed
+
+          _split_packages.drop 1 # Drop the original package to ensure only generated packages are returned
+        end
+
+        def choose_package(generated_packages, content_to_add)
+          # Implements worst fit, add to package with most space left over after addition.
+          # See: http://www.labri.fr/perso/eyraud/pmwiki/uploads/Main/BinPackingSurvey.pdf,
+          # for survey of other techniques
+          package_to_use     = nil
+          available_space    = -1
+
+          generated_packages.each do |generated_package|
+            generated_package_weight = generated_package.weight
+            if (generated_package_weight + content_to_add.weight <= threshold) &&
+                (available_space < threshold - generated_package_weight)
+              package_to_use = generated_package
+              available_space = threshold - generated_package_weight
+            end
+          end
+
+          package_to_use
+        end
+
+        def split_package_contents_over_threshold(package)
+          package.contents.flat_map do |content|
+            if content.weight > threshold && content.splittable_by_weight?
+              split_content_item_over_threshold content
+            else
+              content
+            end
+          end
+        end
+
+        def split_content_item_over_threshold(content_item)
+          per_content_max_quantity = (threshold / content_item.variant_weight).floor
+          per_content_max_quantity = 1 if per_content_max_quantity.zero?
+          content_items = [content_item]
+          while content_item.quantity > per_content_max_quantity
+            split_inventory = InventoryUnit.split(content_item.inventory_unit, per_content_max_quantity)
+            content_items << ContentItem.new(split_inventory, content_item.state)
+          end
+          content_items
         end
       end
     end
   end
 end
-