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/middleware_runner.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Spree
+  module MiddlewareRunner
+    def self.call(middlewares, context)
+      chain = middlewares.to_a.reverse.reduce(->(_ctx) {}) { |inner, klass|
+        ->(ctx) { klass.new.call(ctx, &inner) }
+      }
+
+      chain.call(context)
+    end
+  end
+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,16 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Coordinator
+      def initialize(order, inventory_units: nil)
+        @order = order
+        @context = Context.new(order: order, inventory_units: inventory_units)
+      end
+
+      def shipments
+          Spree::MiddlewareRunner.call(Spree::Config.stock.coordinator_middlewares, @context)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Spree
+  module Stock
+    class Coordinator
+      class Context
+        attr_reader :order
+        attr_accessor :inventory_units, :inventory_unit_groups, :stock_locations,
+          :on_hand_packages, :backordered_packages,
+          :packages, :shipments
+
+        def initialize(order:, inventory_units: nil)
+          @order = order
+          @inventory_units = inventory_units
+        end
+
+        def desired
+          @desired ||= Spree::StockQuantities.new(inventory_unit_groups.transform_values(&:count))
+        end
+
+        def availability
+          @availability ||= Spree::Stock::Availability.new(
+            variants: desired.variants,
+            stock_locations: stock_locations
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Spree
+  module Stock
+    module Middleware
+      class Allocate
+        def call(context)
+          allocator = Spree::Config.stock.allocator_class.new(context.availability)
+          on_hand_packages, backordered_packages, leftover = allocator.allocate_inventory(context.desired)
+
+          raise Spree::Order::InsufficientStock.new(items: leftover.quantities) unless leftover.empty?
+
+          context.on_hand_packages = on_hand_packages
+          context.backordered_packages = backordered_packages
+
+          yield context
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,13 @@
+module Spree
+  module Stock
+    module Middleware
+      class InventoryUnitGroup
+        def call(context)
+          context.inventory_unit_groups = context.inventory_units.group_by(&:variant)
+
+          yield context
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Spree
+  module Stock
+    module Middleware
+      class Package
+        def call(context)
+          packages = context.stock_locations.map do |stock_location|
+            on_hand = context.on_hand_packages[stock_location.id] || Spree::StockQuantities.new
+            backordered = context.backordered_packages[stock_location.id] || Spree::StockQuantities.new
+
+            next if on_hand.empty? && backordered.empty?
+
+            package = Spree::Stock::Package.new(stock_location)
+            package.add_multiple(get_units(context, on_hand), :on_hand)
+            package.add_multiple(get_units(context, backordered), :backordered)
+
+            package
+          end.compact
+
+          context.packages = split_packages(packages)
+
+          yield context
+        end
+
+        private
+
+        def get_units(context, quantities)
+          quantities.flat_map do |variant, quantity|
+            context.inventory_unit_groups[variant].shift(quantity)
+          end
+        end
+
+        def split_packages(initial_packages)
+          splitters = Spree::Config.environment.stock_splitters
+
+          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
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Spree
+  module Stock
+    module Middleware
+      class Shipment
+        def call(context)
+          context.shipments = context.packages.map do |package|
+            shipment = package.shipment = package.to_shipment
+            shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
+            shipment
+          end
+
+          yield context
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Spree
+  module Stock
+    module Middleware
+      class StockLocation
+        def call(context)
+          filtered_stock_locations = Spree::Config.stock.location_filter_class.new(
+            load_stock_locations, context.order
+          ).filter
+          sorted_stock_locations = Spree::Config.stock.location_sorter_class.new(
+            filtered_stock_locations
+          ).sort
+
+          context.stock_locations = sorted_stock_locations
+
+          yield context
+        end
+
+        private
+
+        def load_stock_locations
+          Spree::StockLocation.all
+        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

core/lib/spree/core/class_constantizer.rb

@@ -1,41 +1,11 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/module"
-
 module Spree
   module Core
     module ClassConstantizer
-      class Set
-        include Enumerable
-
-        def initialize(default: [])
-          @collection = ::Set.new(default)
-        end
-
-        def <<(klass)
-          @collection << klass.to_s
-        end
-
-        def concat(klasses)
-          klasses.each do |klass|
-            self << klass
-          end
-
-          self
-        end
-
-        delegate :clear, :empty?, to: :@collection
-
-        def delete(object)
-          @collection.delete(object.to_s)
-        end
-
-        def each
-          @collection.each do |klass|
-            yield klass.constantize
-          end
-        end
-      end
     end
   end
 end
+
+require "spree/core/class_constantizer/set"
+require "spree/core/class_constantizer/list"

core/lib/spree/core/class_constantizer/list.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+
+module Spree
+  module Core
+    module ClassConstantizer
+      # Ordered, array-backed companion to {ClassConstantizer::Set}.
+      #
+      # Stores class references as strings and constantizes them lazily on
+      # iteration, so entries survive code reloading in development. Unlike
+      # {ClassConstantizer::Set}, order is preserved.
+      class List
+        include Enumerable
+
+        def initialize
+          @collection = []
+        end
+
+        def <<(klass)
+          @collection << klass.to_s
+          self
+        end
+
+        def concat(klasses)
+          klasses.each { |klass| self << klass }
+          self
+        end
+
+        def each
+          @collection.each { |klass| yield klass.constantize }
+        end
+
+        # Inserts one or more entries immediately before the anchor.
+        #
+        # @raise [ArgumentError] if the anchor is not in the list.
+        def insert_before(anchor, *klasses)
+          index = index_for(anchor) or
+            raise ArgumentError, "#{anchor} not found in #{self.class}"
+          @collection.insert(index, *klasses.map(&:to_s))
+          self
+        end
+
+        # Inserts one or more entries immediately after the anchor.
+        #
+        # @raise [ArgumentError] if the anchor is not in the list.
+        def insert_after(anchor, *klasses)
+          index = index_for(anchor) or
+            raise ArgumentError, "#{anchor} not found in #{self.class}"
+          @collection.insert(index + 1, *klasses.map(&:to_s))
+          self
+        end
+
+        def delete(object)
+          @collection.delete(object.to_s)
+        end
+
+        private
+
+        def index_for(object)
+          @collection.index(object.to_s)
+        end
+      end
+    end
+  end
+end

core/lib/spree/core/class_constantizer/set.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module"
+
+module Spree
+  module Core
+    module ClassConstantizer
+      class Set
+        include Enumerable
+
+        def initialize(default: [])
+          @collection = ::Set.new(default)
+        end
+
+        def <<(klass)
+          @collection << klass.to_s
+        end
+
+        def concat(klasses)
+          klasses.each do |klass|
+            self << klass
+          end
+
+          self
+        end
+
+        delegate :clear, :empty?, to: :@collection
+
+        def delete(object)
+          @collection.delete(object.to_s)
+        end
+
+        def each
+          @collection.each do |klass|
+            yield klass.constantize
+          end
+        end
+      end
+    end
+  end
+end