solidus_core 4.3.5 → 4.4.1

data/app/models/spree/order.rb

@@ -62,7 +62,7 @@ module Spree
       go_to_state :confirm
     end
 
-    self.allowed_ransackable_associations = %w[shipments user order_promotions promotions bill_address ship_address line_items]
+    self.allowed_ransackable_associations = %w[shipments user bill_address ship_address line_items]
     self.allowed_ransackable_attributes = %w[completed_at created_at email number state payment_state shipment_state total store_id]
 
     attr_reader :coupon_code
@@ -108,8 +108,6 @@ module Spree
              foreign_key: :order_id,
              dependent: :destroy,
              inverse_of: :order
-    has_many :order_promotions, class_name: 'Spree::OrderPromotion', dependent: :destroy
-    has_many :promotions, through: :order_promotions
 
     # Payments
     has_many :payments, dependent: :destroy, inverse_of: :order
@@ -181,7 +179,7 @@ module Spree
     end
 
     def self.by_state(state)
-      where(state: state)
+      where(state:)
     end
 
     def self.complete
@@ -229,7 +227,7 @@ module Spree
     end
 
     def shipping_discount
-      shipment_adjustments.credit.eligible.sum(:amount) * - 1
+      shipment_adjustments.credit.sum(:amount) * - 1
     end
 
     def to_param
@@ -316,7 +314,7 @@ module Spree
 
       if persisted?
         # immediately persist the changes we just made, but don't use save since we might have an invalid address associated
-        self.class.unscoped.where(id: id).update_all(attrs_to_set)
+        self.class.unscoped.where(id:).update_all(attrs_to_set)
       end
 
       assign_attributes(attrs_to_set)
@@ -450,7 +448,7 @@ module Spree
       line_items.destroy_all
       adjustments.destroy_all
       shipments.destroy_all
-      order_promotions.destroy_all
+      Spree::Bus.publish :order_emptied, order: self
 
       recalculate
     end
@@ -464,7 +462,7 @@ module Spree
     end
 
     def can_add_coupon?
-      Spree::Promotion.order_activatable?(self)
+      Spree::Config.promotions.coupon_code_handler_class.new(self).can_apply?
     end
 
     def shipped?
@@ -508,11 +506,6 @@ module Spree
       end
     end
 
-    def apply_shipping_promotions
-      Spree::Config.shipping_promotion_handler_class.new(self).activate
-      recalculate
-    end
-
     # Clean shipments and make order back to address state (or to whatever state
     # is set by restart_checkout_flow in case of state machine modifications)
     def check_shipments_and_restart_checkout
@@ -577,7 +570,7 @@ module Spree
 
     def add_store_credit_payments
       return if user.nil?
-      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency: currency).zero?
+      return if payments.store_credits.checkout.empty? && user.available_store_credit_total(currency:).zero?
 
       payments.store_credits.checkout.each(&:invalidate!)
 
@@ -588,7 +581,7 @@ module Spree
 
       remaining_total = outstanding_balance - authorized_total
 
-      matching_store_credits = user.store_credits.where(currency: currency)
+      matching_store_credits = user.store_credits.where(currency:)
 
       if matching_store_credits.any?
         payment_method = Spree::PaymentMethod::StoreCredit.first
@@ -600,7 +593,7 @@ module Spree
 
           amount_to_take = [credit.amount_remaining, remaining_total].min
           payments.create!(source: credit,
-                           payment_method: payment_method,
+                           payment_method:,
                            amount: amount_to_take,
                            state: 'checkout',
                            response_code: credit.generate_authorization_code)
@@ -624,13 +617,13 @@ module Spree
 
     def covered_by_store_credit?
       return false unless user
-      user.available_store_credit_total(currency: currency) >= total
+      user.available_store_credit_total(currency:) >= total
     end
     alias_method :covered_by_store_credit, :covered_by_store_credit?
 
     def total_available_store_credit
       return 0.0 unless user
-      user.available_store_credit_total(currency: currency)
+      user.available_store_credit_total(currency:)
     end
 
     def order_total_after_store_credit
@@ -641,16 +634,16 @@ module Spree
       if can_complete? || complete?
         valid_store_credit_payments.to_a.sum(&:amount)
       else
-        [total, user.try(:available_store_credit_total, currency: currency) || 0.0].min
+        [total, user.try(:available_store_credit_total, currency:) || 0.0].min
       end
     end
 
     def display_total_applicable_store_credit
-      Spree::Money.new(-total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(-total_applicable_store_credit, { currency: })
     end
 
     def display_store_credit_remaining_after_capture
-      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: currency })
+      Spree::Money.new(total_available_store_credit - total_applicable_store_credit, { currency: })
     end
 
     def bill_address_attributes=(attributes)
@@ -799,7 +792,7 @@ module Spree
     end
 
     def ensure_promotions_eligible
-      Spree::Config.promotion_adjuster_class.new(self).call
+      Spree::Config.promotions.order_adjuster_class.new(self).call
 
       if promo_total_changed?
         restart_checkout_flow

data/app/models/spree/order_cancellations.rb

@@ -36,7 +36,7 @@ class Spree::OrderCancellations
     Spree::OrderMutex.with_lock!(@order) do
       Spree::InventoryUnit.transaction do
         inventory_units.each do |iu|
-          unit_cancels << short_ship_unit(iu, created_by: created_by)
+          unit_cancels << short_ship_unit(iu, created_by:)
         end
 
         update_shipped_shipments(inventory_units)
@@ -67,9 +67,9 @@ class Spree::OrderCancellations
 
     Spree::OrderMutex.with_lock!(@order) do
       unit_cancel = Spree::UnitCancel.create!(
-        inventory_unit: inventory_unit,
-        reason: reason,
-        created_by: created_by
+        inventory_unit:,
+        reason:,
+        created_by:
       )
 
       inventory_unit.cancel!
@@ -89,8 +89,8 @@ class Spree::OrderCancellations
 
     Spree::OrderMutex.with_lock!(@order) do
       return_items = inventory_units.map(&:current_or_new_return_item)
-      reimbursement = Spree::Reimbursement.new(order: @order, return_items: return_items)
-      reimbursement.return_all(created_by: created_by)
+      reimbursement = Spree::Reimbursement.new(order: @order, return_items:)
+      reimbursement.return_all(created_by:)
     end
 
     reimbursement
@@ -100,9 +100,9 @@ class Spree::OrderCancellations
 
   def short_ship_unit(inventory_unit, created_by: nil)
     unit_cancel = Spree::UnitCancel.create!(
-      inventory_unit: inventory_unit,
+      inventory_unit:,
       reason: Spree::UnitCancel::SHORT_SHIP,
-      created_by: created_by
+      created_by:
     )
     unit_cancel.adjust!
     inventory_unit.cancel!

data/app/models/spree/order_mutex.rb

@@ -16,10 +16,10 @@ module Spree
         raise ArgumentError, "order must be supplied" if order.nil?
 
         # limit the maximum lock time just in case a lock is somehow left in place accidentally
-        expired.where(order: order).delete_all
+        expired.where(order:).delete_all
 
         begin
-          order_mutex = create!(order: order)
+          order_mutex = create!(order:)
         rescue ActiveRecord::RecordNotUnique
           error = LockFailed.new("Could not obtain lock on order #{order.id}")
           logger.error error.inspect

data/app/models/spree/order_shipping.rb

@@ -22,11 +22,11 @@ class Spree::OrderShipping
       address: shipment.order.ship_address,
       shipping_method: shipment.shipping_method,
       shipped_at: Time.current,
-      external_number: external_number,
+      external_number:,
       # TODO: Remove the `|| shipment.tracking` once Shipment#ship! is called by
       # OrderShipping#ship rather than vice versa
       tracking_number: tracking_number || shipment.tracking,
-      suppress_mailer: suppress_mailer
+      suppress_mailer:
     )
   end
 
@@ -51,12 +51,12 @@ class Spree::OrderShipping
       inventory_units.each(&:ship!)
 
       carton = Spree::Carton.create!(
-        stock_location: stock_location,
-        address: address,
-        shipping_method: shipping_method,
-        inventory_units: inventory_units,
-        shipped_at: shipped_at,
-        external_number: external_number,
+        stock_location:,
+        address:,
+        shipping_method:,
+        inventory_units:,
+        shipped_at:,
+        external_number:,
         tracking: tracking_number
       )
     end
@@ -80,7 +80,7 @@ class Spree::OrderShipping
 
   def send_shipment_emails(carton)
     carton.orders.each do |order|
-      Spree::Config.carton_shipped_email_class.shipped_email(order: order, carton: carton).deliver_later
+      Spree::Config.carton_shipped_email_class.shipped_email(order:, carton:).deliver_later
     end
   end
 end

data/app/models/spree/order_updater.rb

@@ -26,7 +26,7 @@ module Spree
           update_shipments
           update_shipment_state
         end
-        Spree::Bus.publish :order_recalculated, order: order
+        Spree::Bus.publish(:order_recalculated, order:)
         persist_totals
       end
     end
@@ -114,7 +114,6 @@ module Spree
       # http://www.boe.ca.gov/formspubs/pub113/
       update_promotions
       update_taxes
-      update_cancellations
       update_item_totals
     end
 
@@ -158,9 +157,9 @@ module Spree
       recalculate_adjustments
 
       all_items = line_items + shipments
-      order_tax_adjustments = adjustments.select(&:eligible?).select(&:tax?)
+      order_tax_adjustments = adjustments.select(&:tax?)
 
-      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.select(&:eligible?).sum(&:amount)
+      order.adjustment_total = all_items.sum(&:adjustment_total) + adjustments.sum(&:amount)
       order.included_tax_total = all_items.sum(&:included_tax_total) + order_tax_adjustments.select(&:included?).sum(&:amount)
       order.additional_tax_total = all_items.sum(&:additional_tax_total) + order_tax_adjustments.reject(&:included?).sum(&:amount)
 
@@ -189,14 +188,14 @@ module Spree
         order.state_changes.new(
           previous_state: old_state,
           next_state:     new_state,
-          name:           name,
+          name:,
           user_id:        order.user_id
         )
       end
     end
 
     def update_promotions
-      Spree::Config.promotion_adjuster_class.new(order).call
+      Spree::Config.promotions.order_adjuster_class.new(order).call
     end
 
     def update_taxes
@@ -217,17 +216,14 @@ module Spree
     end
 
     def update_cancellations
-      line_items.each do |line_item|
-        line_item.adjustments.select(&:cancellation?).each(&:recalculate)
-      end
     end
+    deprecate :update_cancellations, deprecator: Spree.deprecator
 
     def update_item_totals
       [*line_items, *shipments].each do |item|
         # The cancellation_total isn't persisted anywhere but is included in
         # the adjustment_total
         item.adjustment_total = item.adjustments.
-          select(&:eligible?).
           reject(&:included?).
           sum(&:amount)
 

data/app/models/spree/payment/processing.rb

@@ -64,7 +64,7 @@ module Spree
           complete! if handle_response(response)
         end
 
-        capture_events.create!(amount: amount)
+        capture_events.create!(amount:)
       end
 
       # Takes the amount in cents to capture.
@@ -243,7 +243,7 @@ module Spree
           cvv_result: response.cvv_result,
           error_code: response.error_code,
           emv_authorization: response.emv_authorization,
-          gateway_order_id: gateway_order_id,
+          gateway_order_id:,
           order_number: order.number
         }
       end

data/app/models/spree/payment.rb

@@ -69,7 +69,7 @@ module Spree
 
     # @return [Spree::Money] this amount of this payment as money object
     def money
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, { currency: })
     end
     alias display_amount money
 
@@ -211,7 +211,7 @@ module Spree
     def set_unique_identifier
       loop do
         self.number = generate_identifier
-        break unless self.class.exists?(number: number)
+        break unless self.class.exists?(number:)
       end
     end
 

data/app/models/spree/payment_create.rb

@@ -72,7 +72,7 @@ module Spree
 
     def available_cards
       if user_id = order.user_id
-        Spree::CreditCard.where(user_id: user_id)
+        Spree::CreditCard.where(user_id:)
       else
         Spree::CreditCard.none
       end

data/app/models/spree/payment_method/store_credit.rb

@@ -107,7 +107,7 @@ module Spree
       store_credit = Spree::StoreCreditEvent.find_by(authorization_code: auth_code).try(:store_credit)
 
       if store_credit.nil?
-        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code: auth_code, action: action_name), {}, {})
+        ActiveMerchant::Billing::Response.new(false, I18n.t('spree.store_credit.unable_to_find_for_action', auth_code:, action: action_name), {}, {})
       else
         handle_action_call(store_credit, action, action_name, auth_code)
       end

data/app/models/spree/payment_source.rb

@@ -7,7 +7,11 @@ module Spree
     belongs_to :payment_method, optional: true
 
     has_many :payments, as: :source
-    has_many :wallet_payment_sources, class_name: 'Spree::WalletPaymentSource', as: :payment_source, inverse_of: :payment_source
+    has_many :wallet_payment_sources,
+      class_name: 'Spree::WalletPaymentSource',
+      as: :payment_source,
+      inverse_of: :payment_source,
+      dependent: :destroy
 
     attr_accessor :imported
 

data/app/models/spree/permission_set.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Spree
+  class PermissionSet < Spree::Base
+    has_many :role_permissions
+    has_many :roles, through: :role_permissions
+    validates :name, :set, :privilege, :category, presence: true
+    scope :display_permissions, -> { where(privilege: "display") }
+    scope :management_permissions, -> { where(privilege: "management") }
+  end
+end

data/app/models/spree/product.rb

@@ -16,7 +16,6 @@ module Spree
       self.product_option_types = []
       self.product_properties = []
       self.classifications.destroy_all
-      self.product_promotion_rules = []
     end
 
     has_many :product_option_types, dependent: :destroy, inverse_of: :product
@@ -31,9 +30,6 @@ module Spree
     has_many :classifications, dependent: :delete_all, inverse_of: :product
     has_many :taxons, through: :classifications, before_remove: :remove_taxon
 
-    has_many :product_promotion_rules, dependent: :destroy
-    has_many :promotion_rules, through: :product_promotion_rules
-
     belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products, optional: true
 
@@ -61,6 +57,8 @@ module Spree
     has_many :line_items, through: :variants_including_master
     has_many :orders, through: :line_items
 
+    has_many :option_values, -> { distinct }, through: :variants_including_master
+
     scope :sort_by_master_default_price_amount_asc, -> {
       with_default_price.order('spree_prices.amount ASC')
     }
@@ -131,26 +129,8 @@ module Spree
 
     alias :options :product_option_types
 
-    # The :variants_option_values ransacker filters Spree::Product based on
-    # variant option values ids.
-    #
-    # Usage:
-    # Spree::Product.ransack(
-    #   variants_option_values_in: [option_value_id1, option_value_id2]
-    # ).result
-    ransacker :variants_option_values, formatter: proc { |v|
-      if OptionValue.exists?(v)
-        joins(variants_including_master: :option_values)
-          .where(spree_option_values: { id: v })
-          .distinct
-          .select(:id).arel
-      end
-    } do |parent|
-      parent.table[:id]
-    end
-
-    self.allowed_ransackable_associations = %w[stores variants_including_master master variants]
-    self.allowed_ransackable_attributes = %w[name slug variants_option_values]
+    self.allowed_ransackable_associations = %w[stores variants_including_master master variants option_values]
+    self.allowed_ransackable_attributes = %w[name slug]
     self.allowed_ransackable_scopes = %i[available with_discarded with_all_variant_sku_cont with_kept_variant_sku_cont]
 
     # @return [Boolean] true if there are any variants
@@ -270,7 +250,7 @@ module Spree
       ActiveRecord::Base.transaction do
         # Works around spree_i18n https://github.com/spree/spree/issues/301
         property = Spree::Property.create_with(presentation: property_name).find_or_create_by(name: property_name)
-        product_property = Spree::ProductProperty.where(product: self, property: property).first_or_initialize
+        product_property = Spree::ProductProperty.where(product: self, property:).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
@@ -278,8 +258,7 @@ module Spree
 
     # @return [Array] all advertised and not-rejected promotions
     def possible_promotions
-      promotion_ids = promotion_rules.map(&:promotion_id).uniq
-      Spree::Promotion.advertised.where(id: promotion_ids).reject(&:inactive?)
+      Spree::Config.promotions.advertiser_class.for_product(self)
     end
 
     # The number of on-hand stock items; Infinity if any variant does not track
@@ -384,7 +363,7 @@ module Spree
     end
 
     def remove_taxon(taxon)
-      removed_classifications = classifications.where(taxon: taxon)
+      removed_classifications = classifications.where(taxon:)
       removed_classifications.each(&:remove_from_list)
     end
   end

data/app/models/spree/refund.rb

@@ -21,7 +21,7 @@ module Spree
     delegate :currency, to: :payment
 
     def money
-      Spree::Money.new(amount, { currency: currency })
+      Spree::Money.new(amount, { currency: })
     end
     alias display_amount money
 

data/app/models/spree/reimbursement.rb

@@ -57,7 +57,7 @@ module Spree
       def build_from_customer_return(customer_return)
         order = customer_return.order
         order.reimbursements.build({
-          customer_return: customer_return,
+          customer_return:,
           return_items: customer_return.return_items.accepted.not_reimbursed
         })
       end
@@ -88,7 +88,7 @@ module Spree
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.perform(self, created_by: created_by)
+      reimbursement_performer.perform(self, created_by:)
 
       if unpaid_amount_within_tolerance?
         reimbursed!
@@ -108,7 +108,7 @@ module Spree
       reload
       update!(total: calculated_total)
 
-      reimbursement_performer.simulate(self, created_by: created_by)
+      reimbursement_performer.simulate(self, created_by:)
     end
 
     def return_items_requiring_exchange
@@ -131,7 +131,7 @@ module Spree
     def return_all(created_by:)
       return_items.each(&:accept!)
       save!
-      perform!(created_by: created_by)
+      perform!(created_by:)
     end
 
     # The returned category is used as the category

data/app/models/spree/reimbursement_performer.rb

@@ -12,12 +12,12 @@ module Spree
       # - #display_amount
       # so they can be displayed in the Admin UI appropriately.
       def simulate(reimbursement, created_by:)
-        execute(reimbursement, true, created_by: created_by)
+        execute(reimbursement, true, created_by:)
       end
 
       # Actually perform the reimbursement
       def perform(reimbursement, created_by:)
-        execute(reimbursement, false, created_by: created_by)
+        execute(reimbursement, false, created_by:)
       end
 
       private
@@ -26,7 +26,7 @@ module Spree
         reimbursement_type_hash = calculate_reimbursement_types(reimbursement)
 
         reimbursement_type_hash.flat_map do |reimbursement_type, return_items|
-          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by: created_by)
+          reimbursement_type.reimburse(reimbursement, return_items, simulate, created_by:)
         end
       end
 

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -26,8 +26,8 @@ module Spree
         included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
 
         return_item.update!({
-          additional_tax_total: additional_tax_total,
-          included_tax_total:   included_tax_total
+          additional_tax_total:,
+          included_tax_total:
         })
       end
     end

data/app/models/spree/reimbursement_type/credit.rb

@@ -7,7 +7,7 @@ module Spree
     class << self
       def reimburse(reimbursement, return_items, simulate, created_by:)
         unpaid_amount = return_items.sum(&:total).round(2, :down)
-        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by: created_by)
+        reimbursement_list, _unpaid_amount = create_credits(reimbursement, unpaid_amount, simulate, created_by:)
         reimbursement_list
       end
     end

data/app/models/spree/reimbursement_type/reimbursement_helpers.rb

@@ -21,7 +21,7 @@ module Spree
     end
 
     def create_credits(reimbursement, unpaid_amount, simulate, reimbursement_list = [], created_by:)
-      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by: created_by)]
+      credits = [create_credit(reimbursement, unpaid_amount, simulate, created_by:)]
       unpaid_amount -= credits.sum(&:amount)
       reimbursement_list += credits
 
@@ -32,8 +32,8 @@ module Spree
 
     def create_refund(reimbursement, payment, amount, simulate)
       refund = reimbursement.refunds.build({
-        payment: payment,
-        amount: amount,
+        payment:,
+        amount:,
         reason: Spree::RefundReason.return_processing_reason
       })
 
@@ -50,8 +50,8 @@ module Spree
     # If you have multiple methods of crediting a customer, overwrite this method
     # Must return an array of objects the respond to #description, #display_amount
     def create_credit(reimbursement, unpaid_amount, simulate, created_by:)
-      creditable = create_creditable(reimbursement, unpaid_amount, created_by: created_by)
-      credit = reimbursement.credits.build(creditable: creditable, amount: unpaid_amount)
+      creditable = create_creditable(reimbursement, unpaid_amount, created_by:)
+      credit = reimbursement.credits.build(creditable:, amount: unpaid_amount)
       simulate ? credit.readonly! : credit.save!
       credit
     end
@@ -61,7 +61,7 @@ module Spree
         user: reimbursement.order.user,
         amount: unpaid_amount,
         category: reimbursement.store_credit_category,
-        created_by: created_by,
+        created_by:,
         memo: "Refund for uncreditable payments on order #{reimbursement.order.number}",
         currency: reimbursement.order.currency
       )

data/app/models/spree/reimbursement_type/store_credit.rb

@@ -25,7 +25,7 @@ class Spree::ReimbursementType::StoreCredit < Spree::ReimbursementType
           unpaid_amount,
           simulate,
           reimbursement_list,
-          created_by: created_by
+          created_by:
         )
       end
 

data/app/models/spree/return_item.rb

@@ -53,7 +53,7 @@ module Spree
     scope :not_expired, -> { where.not(reception_status: 'expired') }
     scope :received, -> { where(reception_status: 'received') }
     INTERMEDIATE_RECEPTION_STATUSES.each do |reception_status|
-      scope reception_status, -> { where(reception_status: reception_status) }
+      scope reception_status, -> { where(reception_status:) }
     end
     scope :pending, -> { where(acceptance_status: 'pending') }
     scope :accepted, -> { where(acceptance_status: 'accepted') }
@@ -93,8 +93,8 @@ module Spree
     # @return [Spree::ReturnItem] a valid return item for the given inventory
     #   unit if one exists, or a new one if one does not
     def self.from_inventory_unit(inventory_unit)
-      valid.find_by(inventory_unit: inventory_unit) ||
-        new(inventory_unit: inventory_unit).tap(&:set_default_amount)
+      valid.find_by(inventory_unit:) ||
+        new(inventory_unit:).tap(&:set_default_amount)
     end
 
     # @return [Boolean] true when an exchange has been requested on this return
@@ -130,7 +130,7 @@ module Spree
     # @return [ActiveRecord::Relation<Spree::Variant>] the variants eligible
     #   for exchange for this return item
     def eligible_exchange_variants(stock_locations = nil)
-      exchange_variant_engine.eligible_variants(variant, stock_locations: stock_locations)
+      exchange_variant_engine.eligible_variants(variant, stock_locations:)
     end
 
     # Builds the exchange inventory unit for this return item, only if an
@@ -248,20 +248,20 @@ module Spree
 
     def validate_no_other_completed_return_items
       other_return_item = Spree::ReturnItem.where({
-        inventory_unit_id: inventory_unit_id,
+        inventory_unit_id:,
         reception_status: COMPLETED_RECEPTION_STATUSES
-      }).where.not(id: id).first
+      }).where.not(id:).first
 
       if other_return_item && (new_record? || COMPLETED_RECEPTION_STATUSES.include?(reception_status.to_sym))
         errors.add(:inventory_unit, :other_completed_return_item_exists,
-          inventory_unit_id: inventory_unit_id,
+          inventory_unit_id:,
           return_item_id: other_return_item.id)
       end
     end
 
     def cancel_others
-      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id)
-                       .where.not(id: id)
+      Spree::ReturnItem.where(inventory_unit_id:)
+                       .where.not(id:)
                        .valid
                        .each(&:cancel!)
     end