Introduce new middleware stock coordinator

core/app/models/spree/exchange.rb

@@ -22,7 +22,10 @@ def display_amount
 
     def perform!
       begin
-        shipments = Spree::Config.stock.coordinator_class.new(@order, @reimbursement_objects.map(&:build_exchange_inventory_unit)).shipments
+        shipments = Spree::Config.stock.coordinator_class.new(
+          @order,
+          inventory_units: @reimbursement_objects.map(&:build_exchange_inventory_unit)
+        ).shipments
       rescue Spree::Order::InsufficientStock
         raise UnableToCreateShipments.new("Could not generate shipments for all items. Out of stock?")
       end

core/app/models/spree/order.rb

@@ -513,9 +513,9 @@ def create_proposed_shipments
     end
 
     def create_shipments_for_line_item(line_item)
-      units = Spree::Config.stock.inventory_unit_builder_class.new(self).missing_units_for_line_item(line_item)
+      inventory_units = Spree::Config.stock.inventory_unit_builder_class.new(self).missing_units_for_line_item(line_item)
 
-      Spree::Config.stock.coordinator_class.new(self, units).shipments.each do |shipment|
+      Spree::Config.stock.coordinator_class.new(self, inventory_units:).shipments.each do |shipment|
         shipments << shipment
       end
     end

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

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Coordinator
+      def initialize(order, inventory_units: nil)
+        context = {order:, inventory_units:}
+        @order = order
+
+        Middleware::InventoryUnit.new.call(context)
+        @inventory_units = context[:inventory_units]
+
+        @splitters = Spree::Config.environment.stock_splitters
+
+        @filtered_stock_locations = Spree::Config.stock.location_filter_class.new(load_stock_locations, order).filter
+        sorted_stock_locations = Spree::Config.stock.location_sorter_class.new(@filtered_stock_locations).sort
+        @stock_locations = sorted_stock_locations
+
+        @desired = Spree::StockQuantities.new(@inventory_units_by_variant.transform_values(&:count))
+        @availability = Spree::Stock::Availability.new(
+          variants: @desired.variants,
+          stock_locations: @stock_locations
+        )
+
+        @allocator = Spree::Config.stock.allocator_class.new(@availability)
+      end
+
+      def shipments
+        @shipments ||= begin
+                         @packages = build_packages
+                         shipments = build_shipments
+
+                         # Make sure we don't add the proposed shipments to the order
+                         @order.shipments = @order.shipments - shipments
+
+                         shipments
+                       end
+      end
+
+      private
+
+      def load_stock_locations
+        Spree::StockLocation.all
+      end
+
+      def build_shipments
+        # Turn the Stock::Packages into a Shipment with rates
+        @packages.map do |package|
+          shipment = package.shipment = package.to_shipment
+          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
+          shipment
+        end
+      end
+
+      def build_packages
+        # Allocate any available on hand inventory and remaining desired inventory from backorders
+        on_hand_packages, backordered_packages, leftover = @allocator.allocate_inventory(@desired)
+
+        raise Spree::Order::InsufficientStock.new(items: leftover.quantities) unless leftover.empty?
+
+        packages = @stock_locations.map do |stock_location|
+          # Combine on_hand and backorders into a single package per-location
+          on_hand = on_hand_packages[stock_location.id] || Spree::StockQuantities.new
+          backordered = backordered_packages[stock_location.id] || Spree::StockQuantities.new
+
+          # Skip this location it has no inventory
+          next if on_hand.empty? && backordered.empty?
+
+          # Turn our raw quantities into a Stock::Package
+          package = Spree::Stock::Package.new(stock_location)
+          package.add_multiple(get_units(on_hand), :on_hand)
+          package.add_multiple(get_units(backordered), :backordered)
+
+          package
+        end.compact
+
+        # Split the packages
+        split_packages(packages)
+      end
+
+      def split_packages(initial_packages)
+        initial_packages.flat_map do |initial_package|
+          stock_location = initial_package.stock_location
+          Spree::Stock::SplitterChain.new(stock_location, @splitters).split([initial_package])
+        end
+      end
+
+      def get_units(quantities)
+        # Change our raw quantities back into inventory units
+        quantities.flat_map do |variant, quantity|
+          @inventory_units_by_variant[variant].shift(quantity)
+        end
+      end
+
+    end
+  end
+end
+

core/app/models/spree/stock/middleware/inventory_unit.rb

@@ -0,0 +1,15 @@
+module Spree
+  module Stock
+    module Middleware
+      class InventoryUnit
+        def call(context)
+          order = context[:order]
+
+          context[:inventory_units] = context[:inventory_units] ||
+            Spree::Config.stock.inventory_unit_builder_class.new(order).units
+        end
+      end
+    end
+  end
+end
+

core/app/models/spree/stock/simple_coordinator.rb

@@ -27,7 +27,14 @@ class SimpleCoordinator
         :filtered_stock_locations, :inventory_units_by_variant, :desired,
         :availability, :allocator, :packages
 
-      def initialize(order, inventory_units = nil)
+      def initialize(order, inventory_units_deprecated = nil, inventory_units: nil)
+        if inventory_units_deprecated
+          Spree.deprecator.warn "Using the `inventory_units` positional " \
+            "argument is deprecated in favor of using the keyword argument. "
+
+          inventory_units ||= inventory_units_deprecated
+        end
+
         @order = order
         @inventory_units =
           inventory_units || Spree::Config.stock.inventory_unit_builder_class.new(order).units