Change Benefit#discount to dynamically call methods on benefits

Similar to the work in #6360, this improves the DSL for creating
benefits. Rather than having to define one method that cares for
applicability to a discountable, we now simply define that a benefit
`#can_discount?` an object if its public interface has
`#discount_{discountable_type}` defined.

This does not change the implementation of the different methods, but
that will come when we refactor the promotion system to use a single
system of record for discounts. Then, different objects will need
different discount records (line items and shipment use adjustments, but
shipping rates use shipping rate discounts etc.).

I'm not doing the work for adding deprecation warnings here, as this
code was never meant to be overridden up to now.

Author: mamhoff

promotions/app/models/solidus_promotions/benefit.rb

@@ -11,9 +11,9 @@ module SolidusPromotions
   # Subclasses specialize the discounting target (orders, line items, or
   # shipments) and usually include one of the following mixins to integrate with
   # Solidus' adjustment system:
-  # - SolidusPromotions::Benefits::OrderBenefit
-  # - SolidusPromotions::Benefits::LineItemBenefit
-  # - SolidusPromotions::Benefits::ShipmentBenefit
+  # - SolidusPromotions::Benefits::AdjustLineItem
+  # - SolidusPromotions::Benefits::AdjustShipment
+  # - SolidusPromotions::Benefits::CreateDiscountedItem
   #
   # A benefit can discount any object for which {#can_discount?} returns true.
   # Implementors must provide a calculator via Spree::CalculatedAdjustments and
@@ -81,13 +81,11 @@ def preload_relations
     #
     # @param object [Object] a potential adjustable (order, line item, or shipment)
     # @return [Boolean]
-    # @raise [NotImplementedError] when not implemented by the subclass/mixin
-    # @see SolidusPromotions::Benefits::OrderBenefit,
-    #      SolidusPromotions::Benefits::LineItemBenefit,
-    #      SolidusPromotions::Benefits::ShipmentBenefit
+    # @see SolidusPromotions::Benefits::AdjustLineItem,
+    #      SolidusPromotions::Benefits::AdjustShipment,
+    #      SolidusPromotions::Benefits::CreateDiscountedItem
     def can_discount?(object)
-      raise NotImplementedError, "Please implement the correct interface, or include one of the `SolidusPromotions::Benefits::OrderBenefit`, " \
-        "`SolidusPromotions::Benefits::LineItemBenefit` or `SolidusPromotions::Benefits::ShipmentBenefit` modules"
+      respond_to?(discount_method_for(object))
     end
 
     # Calculates and returns a discount for the given adjustable object.
@@ -96,7 +94,7 @@ def can_discount?(object)
     # an ItemDiscount object representing the discount to be applied. If the computed
     # amount is zero, no discount is returned.
     #
-    # @param adjustable [Object] The object to calculate the discount for (e.g., LineItem, Order, Shipment)
+    # @param adjustable [Object] The object to calculate the discount for (e.g., LineItem, Shipment, ShippingRate)
     # @param ... [args, kwargs] Additional arguments passed to the calculator's compute method
     #
     # @return [SolidusPromotions::ItemDiscount, nil] An ItemDiscount object if a discount applies, nil if the amount is zero
@@ -108,14 +106,11 @@ def can_discount?(object)
     # @see #compute_amount
     # @see #adjustment_label
     def discount(adjustable, ...)
-      amount = compute_amount(adjustable, ...)
-      return if amount.zero?
-      ItemDiscount.new(
-        item: adjustable,
-        label: adjustment_label(adjustable),
-        amount: amount,
-        source: self
-      )
+      if can_discount?(adjustable)
+        send(discount_method_for(adjustable), adjustable, ...)
+      else
+        raise NotImplementedError, "Please implement #{discount_method_for(adjustable)} in your condition"
+      end
     end
 
     # Computes the discount amount for the given adjustable.
@@ -231,6 +226,10 @@ def possible_conditions
 
     private
 
+    def discount_method_for(adjustable)
+      :"discount_#{adjustable.class.name.demodulize.underscore}"
+    end
+
     # Prevents destroying a benefit when it has adjustments on completed orders.
     #
     # Adds an error and aborts the destroy callback chain when such adjustments exist.

promotions/app/models/solidus_promotions/benefits/adjust_line_item.rb

@@ -3,11 +3,26 @@
 module SolidusPromotions
   module Benefits
     class AdjustLineItem < Benefit
-      include SolidusPromotions::Benefits::LineItemBenefit
+      def discount_line_item(line_item, ...)
+        amount = compute_amount(line_item, ...)
+        return if amount.zero?
+
+        ItemDiscount.new(
+          item: line_item,
+          label: adjustment_label(line_item),
+          amount: amount,
+          source: self
+        )
+      end
 
       def possible_conditions
         super + SolidusPromotions.config.line_item_conditions
       end
+
+      def level
+        :line_item
+      end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

promotions/app/models/solidus_promotions/benefits/adjust_shipment.rb

@@ -3,11 +3,38 @@
 module SolidusPromotions
   module Benefits
     class AdjustShipment < Benefit
-      include SolidusPromotions::Benefits::ShipmentBenefit
+      def discount_shipment(shipment, ...)
+        amount = compute_amount(shipment, ...)
+        return if amount.zero?
+
+        ItemDiscount.new(
+          item: shipment,
+          label: adjustment_label(shipment),
+          amount: amount,
+          source: self
+        )
+      end
+
+      def discount_shipping_rate(shipping_rate, ...)
+        amount = compute_amount(shipping_rate, ...)
+        return if amount.zero?
+
+        ItemDiscount.new(
+          item: shipping_rate,
+          label: adjustment_label(shipping_rate),
+          amount: amount,
+          source: self
+        )
+      end
 
       def possible_conditions
         super + SolidusPromotions.config.shipment_conditions
       end
+
+      def level
+        :shipment
+      end
+      deprecate :level, deprecator: Spree.deprecator
     end
   end
 end

promotions/app/models/solidus_promotions/benefits/create_discounted_item.rb

@@ -3,24 +3,40 @@
 module SolidusPromotions
   module Benefits
     class CreateDiscountedItem < Benefit
-      include OrderBenefit
       preference :variant_id, :integer
       preference :quantity, :integer, default: 1
       preference :necessary_quantity, :integer, default: 1
 
       def perform(order)
         line_item = find_item(order) || create_item(order)
         set_quantity(line_item, determine_item_quantity(order))
-        line_item.current_discounts << discount(line_item)
+        line_item.current_discounts << discount_line_item(line_item)
       end
 
       def remove_from(order)
         line_item = find_item(order)
         order.line_items.destroy(line_item)
       end
 
+      def level
+        :order
+      end
+      deprecate :level, deprecator: Spree.deprecator
+
       private
 
+      def discount_line_item(line_item, ...)
+        amount = compute_amount(line_item, ...)
+        return if amount.zero?
+
+        ItemDiscount.new(
+          item: line_item,
+          label: adjustment_label(line_item),
+          amount: amount,
+          source: self
+        )
+      end
+
       def find_item(order)
         order.line_items.detect { |line_item| line_item.managed_by_order_benefit == self }
       end

promotions/spec/models/solidus_promotions/benefit_spec.rb

@@ -12,10 +12,22 @@
   it { is_expected.to respond_to :can_discount? }
 
   describe "#can_adjust?" do
-    subject { described_class.new.can_discount?(double) }
+    let(:adjustable) { Spree::LineItem.new }
+    let(:benefit_class) do
+      Class.new(described_class) do
+        def discount_line_item(line_item, options = {})
+        end
+      end
+    end
 
-    it "raises a NotImplementedError" do
-      expect { subject }.to raise_exception(NotImplementedError)
+    subject { benefit_class.new.can_discount?(adjustable) }
+
+    it { is_expected.to be true }
+
+    context "if passing in an incompatible object" do
+      let(:adjustable) { Spree::Shipment.new }
+
+      it { is_expected.to be false }
     end
   end
 
@@ -69,22 +81,23 @@
   describe "#discount" do
     subject { benefit.discount(discountable) }
 
+    let(:benefit_class) do
+      Class.new(described_class) do
+        def discount_line_item(line_item, options = {})
+        end
+      end
+    end
+
     let(:variant) { create(:variant) }
     let(:order) { create(:order) }
     let(:discountable) { Spree::LineItem.new(order: order, variant: variant, price: 10, quantity: 1) }
     let(:promotion) { SolidusPromotions::Promotion.new(customer_label: "20 Perzent off") }
     let(:calculator) { SolidusPromotions::Calculators::Percent.new(preferred_percent: 20) }
-    let(:benefit) { described_class.new(promotion: promotion, calculator: calculator) }
-
-    it "returns an discount to the discountable" do
-      expect(subject).to eq(
-        SolidusPromotions::ItemDiscount.new(
-          item: discountable,
-          label: "Promotion (20 Perzent off)",
-          source: benefit,
-          amount: -2
-        )
-      )
+    let(:benefit) { benefit_class.new(promotion: promotion, calculator: calculator) }
+
+    it "passes adjustable to discount_line_item" do
+      expect(benefit).to receive(:discount_line_item).with(discountable)
+      subject
     end
 
     context "if the calculator returns nil" do
@@ -106,15 +119,20 @@
     end
 
     context "if passing in extra options" do
+      let(:benefit_class) { SolidusPromotions::Benefits::AdjustLineItem }
       let(:calculator_class) do
         Class.new(Spree::Calculator) do
           def compute_line_item(_line_item, _options) = 1
         end
       end
       let(:calculator) { calculator_class.new }
-      let(:discountable) { build(:line_item) }
+      let(:promotion) { build(:solidus_promotion) }
+      let(:benefit) { benefit_class.new(promotion:, calculator:) }
+      let(:order) { Spree::Order.new }
+      let(:discountable) { build(:line_item, order:) }
 
       subject { benefit.discount(discountable, extra_data: "foo") }
+
       it "passes the option on to the calculator" do
         expect(calculator).to receive(:compute_line_item).with(discountable, extra_data: "foo").and_return(1)
         subject

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

@@ -5,12 +5,28 @@
 RSpec.describe SolidusPromotions::Benefits::CreateDiscountedItem do
   it { is_expected.to respond_to(:preferred_variant_id) }
 
+  describe "#can_discount?" do
+    let(:benefit) { described_class.new }
+    let(:discountable) { Spree::Order.new }
+
+    subject { benefit.can_discount?(discountable) }
+
+    it { is_expected.to be false }
+
+    context "with a line item" do
+      let(:discountable) { Spree::LineItem.new }
+
+      it { is_expected.to be false }
+    end
+  end
+
   describe "#perform" do
     let(:order) { create(:order_with_line_items) }
     let(:promotion) { create(:solidus_promotion) }
     let(:benefit) { SolidusPromotions::Benefits::CreateDiscountedItem.new(preferred_variant_id: goodie.id, calculator: hundred_percent, promotion: promotion) }
     let(:hundred_percent) { SolidusPromotions::Calculators::Percent.new(preferred_percent: 100) }
     let(:goodie) { create(:variant) }
+
     subject { benefit.perform(order) }
 
     it "creates a line item with a hundred percent discount" do