Change order adjuster to use adjustments

This way we can have a single source of truth for what's being
discounted.

Author: mamhoff

promotions/app/models/concerns/solidus_promotions/discountable_amount.rb

@@ -2,20 +2,19 @@
 
 module SolidusPromotions
   module DiscountableAmount
-    def discountable_amount
-      amount + current_discounts.sum(&:amount)
-    end
-
     def current_discounts
       @current_discounts ||= []
     end
+    deprecate current_discounts: :previous_lane_discounts, deprecator: Spree.deprecator
 
     def current_discounts=(args)
       @current_discounts = args
     end
+    deprecate :current_discounts=, deprecator: Spree.deprecator
 
     def reset_current_discounts
       @current_discounts = []
     end
+    deprecate :reset_current_discounts=, deprecator: Spree.deprecator
   end
 end

promotions/app/models/concerns/solidus_promotions/discounted_amount.rb

@@ -24,6 +24,8 @@ def initialize
     def discounted_amount
       amount + previous_lanes_discounts.sum(&:amount)
     end
+    # The discountable amount is always equal to the discounted amount.
+    alias_method :discountable_amount, :discounted_amount
 
     # Returns discount objects from the current promotion lane.
     #

promotions/app/models/solidus_promotions/order_adjuster.rb

@@ -14,23 +14,14 @@ def initialize(order, dry_run_promotion: nil)
     end
 
     def call
-      order.reset_current_discounts
-
       return order unless SolidusPromotions::Promotion.order_activatable?(order)
 
-      discounted_order = DiscountOrder.new(order, promotions, dry_run: dry_run).call
-
-      PersistDiscountedOrder.new(discounted_order).call unless dry_run
+      NullifyOrderDiscounts.new(order:).call
 
-      order.reset_current_discounts
+      DiscountOrder.new(order, promotions, dry_run: dry_run).call
 
       unless dry_run
-        # Since automations might have added a line item, we need to recalculate
-        # item total and item count here.
-        line_items = order.line_items.reject(&:marked_for_destruction?)
-        order.item_total = line_items.sum(&:amount)
-        order.item_count = line_items.sum(&:quantity)
-        order.promo_total = (line_items + order.shipments).sum(&:promo_total)
+        order.save!
       end
       order
     end

promotions/app/models/solidus_promotions/order_adjuster/discount_order.rb

@@ -15,17 +15,37 @@ def call
         return order if order.shipped?
 
         SolidusPromotions::Promotion.ordered_lanes.each do |lane|
-          lane_promotions = promotions.select { |promotion| promotion.lane == lane }
-          lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
-          perform_order_benefits(lane_benefits, lane) unless dry_run
-          line_item_discounts = adjust_line_items(lane_benefits)
-          shipment_discounts = adjust_shipments(lane_benefits)
-          shipping_rate_discounts = adjust_shipping_rates(lane_benefits)
-          (line_item_discounts + shipment_discounts + shipping_rate_discounts).each do |item, chosen_discounts|
-            item.current_discounts.concat(chosen_discounts)
+          SolidusPromotions::PromotionLane.set(current_lane: lane) do
+            lane_promotions = promotions.select { |promotion| promotion.lane == lane }
+            lane_benefits = eligible_benefits_for_promotable(lane_promotions.flat_map(&:benefits), order)
+            perform_order_benefits(lane_benefits, lane) unless dry_run
+            adjust_line_items(lane_benefits)
+            adjust_shipments(lane_benefits)
+            adjust_shipping_rates(lane_benefits)
           end
         end
 
+        order.line_items.each do |line_item|
+          line_item.adjustments.select { _1.amount.zero? }.each(&:mark_for_destruction)
+          line_item.promo_total = line_item.adjustments.reject(&:marked_for_destruction?).sum(&:amount)
+          line_item.adjustment_total = line_item.promo_total
+        end
+
+        order.shipments.each do |shipment|
+          shipment.adjustments.select { _1.amount.zero? }.each(&:mark_for_destruction)
+          shipment.promo_total = shipment.adjustments.reject(&:marked_for_destruction?).sum(&:amount)
+          shipment.shipping_rates.each do |shipping_rate|
+            shipping_rate.discounts.select { _1.amount.zero? }.each(&:mark_for_destruction)
+          end
+          shipment.adjustment_total = shipment.promo_total
+        end
+
+        line_items = order.line_items.reject(&:marked_for_destruction?)
+        order.item_total = line_items.sum(&:amount)
+        order.item_count = line_items.sum(&:quantity)
+        order.promo_total = (line_items + order.shipments.reject(&:marked_for_destruction?)).sum(&:promo_total)
+        order.adjustment_total = order.promo_total
+
         order
       end
 
@@ -49,16 +69,16 @@ def adjust_line_items(benefits)
           next unless line_item.variant.product.promotionable?
 
           discounts = generate_discounts(benefits, line_item)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [line_item, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (line_item.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end
 
       def adjust_shipments(benefits)
         order.shipments.map do |shipment|
           discounts = generate_discounts(benefits, shipment)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [shipment, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (shipment.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end
 
@@ -67,8 +87,8 @@ def adjust_shipping_rates(benefits)
           next unless rate.cost
 
           discounts = generate_discounts(benefits, rate)
-          chosen_item_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
-          [rate, chosen_item_discounts]
+          chosen_discounts = SolidusPromotions.config.discount_chooser_class.new(discounts).call
+          (rate.current_lane_discounts - chosen_discounts).each(&:mark_for_destruction)
         end
       end
 

promotions/app/models/solidus_promotions/shipping_rate_discount.rb

@@ -5,6 +5,8 @@ class ShippingRateDiscount < Spree::Base
     belongs_to :shipping_rate, inverse_of: :discounts, class_name: "Spree::ShippingRate"
     belongs_to :benefit, inverse_of: :shipping_rate_discounts
 
+    alias_method :source, :benefit
+
     extend Spree::DisplayMoney
     money_methods :amount
   end

promotions/spec/models/solidus_promotions/benefit_spec.rb

@@ -141,8 +141,14 @@ def compute_line_item(_line_item, _options) = 1
 
       subject { benefit.discount(discountable, extra_data: "foo") }
 
+      around do |example|
+        SolidusPromotions::PromotionLane.set(current_lane: promotion.lane) do
+          example.run
+        end
+      end
+
       it "passes the option on to the calculator" do
-        expect(calculator).to receive(:compute_line_item).with(discountable, extra_data: "foo").and_return(1)
+        expect(calculator).to receive(:compute_line_item).with(discountable, extra_data: "foo").and_call_original
         subject
       end
     end

promotions/spec/models/solidus_promotions/benefits/adjust_line_item_quantity_groups_spec.rb

@@ -21,6 +21,12 @@
   let(:quantity) { 1 }
   let(:promotion) { create(:solidus_promotion, apply_automatically: true) }
 
+  around do |example|
+    SolidusPromotions::PromotionLane.set(current_lane: promotion.lane) do
+      example.run
+    end
+  end
+
   describe "#compute_amount" do
     subject { action.compute_amount(line_item) }
 

promotions/spec/models/solidus_promotions/benefits/create_discounted_item_spec.rb

@@ -10,6 +10,12 @@
   let(:promotion) { create(:solidus_promotion) }
   let(:goodie) { create(:variant) }
 
+  around do |example|
+    SolidusPromotions::PromotionLane.set(current_lane: promotion.lane) do
+      example.run
+    end
+  end
+
   describe "#can_discount?" do
     let(:benefit) { described_class.new }
     let(:discountable) { Spree::Order.new }

promotions/spec/models/solidus_promotions/calculators/percent_spec.rb

@@ -16,13 +16,14 @@
     end
 
     context "with a shipment" do
-      let(:item) { build(:shipment, cost: 29) }
+      let(:item) { build(:shipment, order:, cost: 29) }
 
       it { is_expected.to eq(4.35) }
     end
 
     context "with a shipping rate" do
-      let(:item) { build(:shipping_rate, cost: 38) }
+      let(:shipment) { build(:shipment, order:, cost: 29) }
+      let(:item) { build(:shipping_rate, shipment:, cost: 38) }
 
       it { is_expected.to eq(5.70) }
     end

promotions/spec/models/solidus_promotions/order_adjuster/discount_order_spec.rb

@@ -10,8 +10,8 @@
     subject { described_class.new(order, promotions).call }
 
     it "returns the order unmodified" do
-      expect(order).not_to receive(:reset_current_discounts)
       expect(subject).to eq(order)
+      expect(order.changes).to be_empty
     end
   end