solidus_core 4.6.4 → 4.7.0

data/app/models/spree/refund.rb

@@ -5,14 +5,14 @@ module Spree
     include Metadata
 
     belongs_to :payment, inverse_of: :refunds, optional: true
-    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id, optional: true
+    belongs_to :reason, class_name: "Spree::RefundReason", foreign_key: :refund_reason_id, optional: true
     belongs_to :reimbursement, inverse_of: :refunds, optional: true
 
     has_many :log_entries, as: :source
 
     validates :payment, presence: true
     validates :reason, presence: true
-    validates :amount, presence: true, numericality: { greater_than: 0 }
+    validates :amount, presence: true, numericality: {greater_than: 0}
 
     validate :amount_is_less_than_or_equal_to_allowed_amount, on: :create
 
@@ -23,9 +23,9 @@ module Spree
     delegate :currency, to: :payment
 
     def money
-      Spree::Money.new(amount, { currency: })
+      Spree::Money.new(amount, {currency:})
     end
-    alias display_amount money
+    alias_method :display_amount, :money
 
     class << self
       def total_amount_reimbursed_for(reimbursement)
@@ -68,21 +68,21 @@ module Spree
     # return an activemerchant response object if successful or else raise an error
     def process!(credit_cents)
       response = if payment.payment_method.payment_profiles_supported?
-        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, { originator: self })
+        payment.payment_method.credit(credit_cents, payment.source, payment.transaction_id, {originator: self})
       else
-        payment.payment_method.credit(credit_cents, payment.transaction_id, { originator: self })
+        payment.payment_method.credit(credit_cents, payment.transaction_id, {originator: self})
       end
 
       if !response.success?
-        logger.error(I18n.t('spree.gateway_error') + "  #{response.to_yaml}")
-        text = response.params['message'] || response.params['response_reason_text'] || response.message
+        logger.error(I18n.t("spree.gateway_error") + "  #{response.to_yaml}")
+        text = response.params["message"] || response.params["response_reason_text"] || response.message
         raise Core::GatewayError.new(text)
       end
 
       response
     rescue ActiveMerchant::ConnectionError => error
-      logger.error(I18n.t('spree.gateway_error') + "  #{error.inspect}")
-      raise Core::GatewayError.new(I18n.t('spree.unable_to_connect_to_gateway'))
+      logger.error(I18n.t("spree.gateway_error") + "  #{error.inspect}")
+      raise Core::GatewayError.new(I18n.t("spree.unable_to_connect_to_gateway"))
     end
 
     def amount_is_less_than_or_equal_to_allowed_amount

data/app/models/spree/refund_reason.rb

@@ -5,9 +5,9 @@ module Spree
     scope :active, -> { where(active: true) }
     default_scope -> { order(arel_table[:name].lower) }
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
 
-    RETURN_PROCESSING_REASON = 'Return processing'
+    RETURN_PROCESSING_REASON = "Return processing"
 
     has_many :refunds
 

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

@@ -22,7 +22,7 @@ module Spree
       end
 
       def display_amount
-        Spree::Money.new(amount, { currency: creditable.try(:currency) || "USD" })
+        Spree::Money.new(amount, {currency: creditable.try(:currency) || "USD"})
       end
     end
   end

data/app/models/spree/reimbursement.rb

@@ -8,7 +8,7 @@ module Spree
     belongs_to :customer_return, inverse_of: :reimbursements, touch: true, optional: true
 
     has_many :refunds, inverse_of: :reimbursement
-    has_many :credits, inverse_of: :reimbursement, class_name: 'Spree::Reimbursement::Credit'
+    has_many :credits, inverse_of: :reimbursement, class_name: "Spree::Reimbursement::Credit"
 
     has_many :return_items, inverse_of: :reimbursement
 
@@ -20,7 +20,7 @@ module Spree
     before_create :generate_number
     before_create :calculate_total
 
-    scope :reimbursed, -> { where(reimbursement_status: 'reimbursed') }
+    scope :reimbursed, -> { where(reimbursement_status: "reimbursed") }
 
     # The reimbursement_tax_calculator property should be set to an object that responds to "call"
     # and accepts a reimbursement object. Invoking "call" should update the tax fields on the
@@ -64,7 +64,7 @@ module Spree
     end
 
     def display_total
-      Spree::Money.new(total, { currency: order.currency })
+      Spree::Money.new(total, {currency: order.currency})
     end
 
     def calculated_total
@@ -150,7 +150,7 @@ module Spree
 
     def generate_number
       self.number ||= loop do
-        random = "RI#{Array.new(9){ rand(9) }.join}"
+        random = "RI#{Array.new(9) { rand(9) }.join}"
         break random unless self.class.exists?(number: random)
       end
     end
@@ -172,10 +172,10 @@ module Spree
         model.total_amount_reimbursed_for(self) > 0
       end
       leniency = if reimbursement_count > 0
-                   (reimbursement_count - 1) * 0.01.to_d
-                 else
-                   0
-                 end
+        (reimbursement_count - 1) * BigDecimal("0.01")
+      else
+        0
+      end
       unpaid_amount.abs.between?(0, leniency)
     end
   end

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -23,7 +23,7 @@ module Spree
         percent_of_tax = (return_item.amount <= 0) ? 0 : return_item.amount / Spree::ReturnItem.refund_amount_calculator.new.compute(return_item)
 
         additional_tax_total = percent_of_tax * return_item.inventory_unit.additional_tax_total
-        included_tax_total   = percent_of_tax * return_item.inventory_unit.included_tax_total
+        included_tax_total = percent_of_tax * return_item.inventory_unit.included_tax_total
 
         return_item.update!({
           additional_tax_total:,

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

@@ -68,7 +68,7 @@ module Spree
     end
 
     def sorted_eligible_refund_payments(payments)
-      if eligible_refund_methods = self.eligible_refund_methods
+      if (eligible_refund_methods = self.eligible_refund_methods)
         payments = payments.select { |payment| eligible_refund_methods.include? payment.payment_method.class }
         payments = payments.sort_by { |payment| eligible_refund_methods.index(payment.payment_method.class) }
       end

data/app/models/spree/reimbursement_type.rb

@@ -5,9 +5,9 @@ module Spree
     scope :active, -> { where(active: true) }
     default_scope -> { order(arel_table[:name].lower) }
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
 
-    ORIGINAL = 'original'
+    ORIGINAL = "original"
 
     has_many :return_items
 

data/app/models/spree/return_authorization.rb

@@ -6,14 +6,14 @@ module Spree
   class ReturnAuthorization < Spree::Base
     include Metadata
 
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations, optional: true
+    belongs_to :order, class_name: "Spree::Order", inverse_of: :return_authorizations, optional: true
 
     has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
     has_many :inventory_units, through: :return_items, dependent: :nullify
     has_many :customer_returns, through: :return_items
 
     belongs_to :stock_location, optional: true
-    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id, optional: true
+    belongs_to :reason, class_name: "Spree::ReturnReason", foreign_key: :return_reason_id, optional: true
 
     before_create :generate_number
 
@@ -27,9 +27,10 @@ module Spree
     include ::Spree::Config.state_machines.return_authorization
 
     extend DisplayMoney
+
     money_methods :amount, :total_excluding_vat
 
-    self.allowed_ransackable_attributes = ['memo']
+    self.allowed_ransackable_attributes = ["memo"]
 
     def total_excluding_vat
       return_items.sum(&:total_excluding_vat)
@@ -59,20 +60,20 @@ module Spree
 
     def must_have_shipped_units
       if order.nil? || order.inventory_units.shipped.none?
-        errors.add(:order, I18n.t('spree.has_no_shipped_units'))
+        errors.add(:order, I18n.t("spree.has_no_shipped_units"))
       end
     end
 
     def generate_number
       self.number ||= loop do
-        random = "RA#{Array.new(9){ rand(9) }.join}"
+        random = "RA#{Array.new(9) { rand(9) }.join}"
         break random unless self.class.exists?(number: random)
       end
     end
 
     def no_previously_exchanged_inventory_units
       if return_items.map(&:inventory_unit).any?(&:exchange_requested?)
-        errors.add(:base, I18n.t('spree.return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange'))
+        errors.add(:base, I18n.t("spree.return_items_cannot_be_created_for_inventory_units_that_are_already_awaiting_exchange"))
       end
     end
 

data/app/models/spree/return_item/eligibility_validator/base_validator.rb

@@ -12,11 +12,11 @@ module Spree
         end
 
         def eligible_for_return?
-          raise NotImplementedError, I18n.t('spree.implement_eligible_for_return')
+          raise NotImplementedError, I18n.t("spree.implement_eligible_for_return")
         end
 
         def requires_manual_intervention?
-          raise NotImplementedError, I18n.t('spree.implement_requires_manual_intervention')
+          raise NotImplementedError, I18n.t("spree.implement_requires_manual_intervention")
         end
 
         private

data/app/models/spree/return_item/eligibility_validator/default.rb

@@ -28,7 +28,7 @@ module Spree
         private
 
         def validators
-          @validators ||= permitted_eligibility_validators.map{ |validator| validator.new(@return_item) }
+          @validators ||= permitted_eligibility_validators.map { |validator| validator.new(@return_item) }
         end
       end
     end

data/app/models/spree/return_item/eligibility_validator/inventory_shipped.rb

@@ -8,7 +8,7 @@ module Spree
           if @return_item.inventory_unit.shipped?
             true
           else
-            add_error(:inventory_unit_shipped, I18n.t('spree.return_item_inventory_unit_ineligible'))
+            add_error(:inventory_unit_shipped, I18n.t("spree.return_item_inventory_unit_ineligible"))
             false
           end
         end

data/app/models/spree/return_item/eligibility_validator/no_reimbursements.rb

@@ -6,7 +6,7 @@ module Spree
       class NoReimbursements < Spree::ReturnItem::EligibilityValidator::BaseValidator
         def eligible_for_return?
           if @return_item.inventory_unit.return_items.reimbursed.valid.any?
-            add_error(:inventory_unit_reimbursed, I18n.t('spree.return_item_inventory_unit_reimbursed'))
+            add_error(:inventory_unit_reimbursed, I18n.t("spree.return_item_inventory_unit_reimbursed"))
             false
           else
             true

data/app/models/spree/return_item/eligibility_validator/order_completed.rb

@@ -8,7 +8,7 @@ module Spree
           if @return_item.inventory_unit.order.completed?
             true
           else
-            add_error(:order_not_completed, I18n.t('spree.return_item_order_not_completed'))
+            add_error(:order_not_completed, I18n.t("spree.return_item_order_not_completed"))
             false
           end
         end

data/app/models/spree/return_item/eligibility_validator/rma_required.rb

@@ -8,7 +8,7 @@ module Spree
           if @return_item.return_authorization.present?
             true
           else
-            add_error(:rma_required, I18n.t('spree.return_item_rma_ineligible'))
+            add_error(:rma_required, I18n.t("spree.return_item_rma_ineligible"))
             false
           end
         end

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -8,7 +8,7 @@ module Spree
           if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
             true
           else
-            add_error(:number_of_days, I18n.t('spree.return_item_time_period_ineligible'))
+            add_error(:number_of_days, I18n.t("spree.return_item_time_period_ineligible"))
             false
           end
         end

data/app/models/spree/return_item/exchange_variant_eligibility/same_option_value.rb

@@ -30,12 +30,12 @@ module Spree
             # Finds all the OptionValueVariants that have any of the
             # relevant option values, groups by variant and ensures the variant
             # has ALL of the relevant option values.
-            variant_ids = Spree::OptionValuesVariant.
-              where(variant_id: product_variants.distinct.pluck(:id)).
-              where(option_value: relevant_option_values).
-              group(:variant_id).
-              having('COUNT(*) = ?', relevant_option_values.size).
-              pluck(:variant_id)
+            variant_ids = Spree::OptionValuesVariant
+              .where(variant_id: product_variants.distinct.pluck(:id))
+              .where(option_value: relevant_option_values)
+              .group(:variant_id)
+              .having("COUNT(*) = ?", relevant_option_values.size)
+              .pluck(:variant_id)
             product_variants.where(id: variant_ids)
           else
             product_variants

data/app/models/spree/return_item.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ReturnItem < Spree::Base
-    INTERMEDIATE_RECEPTION_STATUSES = %i(given_to_customer lost_in_transit shipped_wrong_item short_shipped in_transit)
+    INTERMEDIATE_RECEPTION_STATUSES = %i[given_to_customer lost_in_transit shipped_wrong_item short_shipped in_transit]
     COMPLETED_RECEPTION_STATUSES = INTERMEDIATE_RECEPTION_STATUSES + [:received]
 
     # @!scope class
@@ -31,37 +31,36 @@ module Spree
 
     belongs_to :return_authorization, inverse_of: :return_items, optional: true
     belongs_to :inventory_unit, inverse_of: :return_items
-    belongs_to :exchange_variant, class_name: 'Spree::Variant', optional: true
-    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item, optional: true
+    belongs_to :exchange_variant, class_name: "Spree::Variant", optional: true
+    belongs_to :exchange_inventory_unit, class_name: "Spree::InventoryUnit", inverse_of: :original_return_item, optional: true
     belongs_to :customer_return, inverse_of: :return_items, optional: true
     belongs_to :reimbursement, inverse_of: :return_items, optional: true
-    belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType', optional: true
-    belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType', optional: true
-    belongs_to :return_reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id, optional: true
+    belongs_to :preferred_reimbursement_type, class_name: "Spree::ReimbursementType", optional: true
+    belongs_to :override_reimbursement_type, class_name: "Spree::ReimbursementType", optional: true
+    belongs_to :return_reason, class_name: "Spree::ReturnReason", foreign_key: :return_reason_id, optional: true
 
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
-    validate :belongs_to_return_authorization_order, if: -> { inventory_unit_id_changed? || return_authorization_id_changed? }
     validate :validate_acceptance_status_for_reimbursement
     validate :validate_no_other_completed_return_items
 
     after_create :cancel_others, unless: :cancelled?
 
-    scope :awaiting_return, -> { where(reception_status: 'awaiting') }
+    scope :awaiting_return, -> { where(reception_status: "awaiting") }
     scope :expecting_return, -> { where.not(reception_status: COMPLETED_RECEPTION_STATUSES) }
-    scope :not_cancelled, -> { where.not(reception_status: 'cancelled') }
-    scope :valid, -> { where.not(reception_status: %w(cancelled expired unexchanged)) }
-    scope :not_expired, -> { where.not(reception_status: 'expired') }
-    scope :received, -> { where(reception_status: 'received') }
+    scope :not_cancelled, -> { where.not(reception_status: "cancelled") }
+    scope :valid, -> { where.not(reception_status: %w[cancelled expired unexchanged]) }
+    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:) }
     end
-    scope :pending, -> { where(acceptance_status: 'pending') }
-    scope :accepted, -> { where(acceptance_status: 'accepted') }
-    scope :rejected, -> { where(acceptance_status: 'rejected') }
-    scope :manual_intervention_required, -> { where(acceptance_status: 'manual_intervention_required') }
-    scope :undecided, -> { where(acceptance_status: %w(pending manual_intervention_required)) }
-    scope :decided, -> { where.not(acceptance_status: %w(pending manual_intervention_required)) }
+    scope :pending, -> { where(acceptance_status: "pending") }
+    scope :accepted, -> { where(acceptance_status: "accepted") }
+    scope :rejected, -> { where(acceptance_status: "rejected") }
+    scope :manual_intervention_required, -> { where(acceptance_status: "manual_intervention_required") }
+    scope :undecided, -> { where(acceptance_status: %w[pending manual_intervention_required]) }
+    scope :decided, -> { where.not(acceptance_status: %w[pending manual_intervention_required]) }
     scope :reimbursed, -> { where.not(reimbursement_id: nil) }
     scope :not_reimbursed, -> { where(reimbursement_id: nil) }
     scope :exchange_requested, -> { where.not(exchange_variant: nil) }
@@ -81,6 +80,7 @@ module Spree
     include ::Spree::Config.state_machines.return_item_acceptance
 
     extend DisplayMoney
+
     money_methods :amount, :total, :total_excluding_vat
 
     # @return [Boolean] true when this retur item is in a complete reception
@@ -169,13 +169,13 @@ module Spree
       event_paths.delete(:expired)
       event_paths.delete(:unexchange)
 
-      status_paths.map{ |status| I18n.t("spree.reception_states.#{status}", default: status.to_s.humanize) }.zip(event_paths)
+      status_paths.map { |status| I18n.t("spree.reception_states.#{status}", default: status.to_s.humanize) }.zip(event_paths)
     end
 
     def part_of_exchange?
       # test whether this ReturnItem was either a) one for which an exchange was sent or
       #   b) the exchanged item itself being returned in lieu of the original item
-      exchange_requested? || sibling_intended_for_exchange('unexchanged')
+      exchange_requested? || sibling_intended_for_exchange("unexchanged")
     end
 
     def currency
@@ -204,7 +204,7 @@ module Spree
     end
 
     def check_unexchange
-      original_ri = sibling_intended_for_exchange('awaiting')
+      original_ri = sibling_intended_for_exchange("awaiting")
       if original_ri
         original_ri.unexchange!
         set_default_amount
@@ -222,14 +222,6 @@ module Spree
       return unless customer_return && inventory_unit
 
       if customer_return.order_id != inventory_unit.order_id
-        errors.add(:base, I18n.t('spree.return_items_cannot_be_associated_with_multiple_orders'))
-      end
-    end
-
-    def belongs_to_return_authorization_order
-      return unless return_authorization && inventory_unit
-
-      if return_authorization.order_id != inventory_unit.order_id
         errors.add(:base, I18n.t("spree.return_items_cannot_be_associated_with_multiple_orders"))
       end
     end
@@ -237,7 +229,7 @@ module Spree
     def eligible_exchange_variant
       return unless exchange_variant && exchange_variant_id_changed?
       unless eligible_exchange_variants.include?(exchange_variant)
-        errors.add(:base, I18n.t('spree.invalid_exchange_variant'))
+        errors.add(:base, I18n.t("spree.invalid_exchange_variant"))
       end
     end
 
@@ -252,7 +244,7 @@ module Spree
     end
 
     def set_exchange_amount
-      self.amount = 0.0.to_d if exchange_requested?
+      self.amount = BigDecimal("0.0") if exchange_requested?
     end
 
     def validate_no_other_completed_return_items
@@ -270,9 +262,9 @@ module Spree
 
     def cancel_others
       Spree::ReturnItem.where(inventory_unit_id:)
-                       .where.not(id:)
-                       .valid
-                       .each(&:cancel!)
+        .where.not(id:)
+        .valid
+        .each(&:cancel!)
     end
 
     def should_restock?

data/app/models/spree/return_reason.rb

@@ -5,7 +5,7 @@ module Spree
     scope :active, -> { where(active: true) }
     default_scope -> { order(arel_table[:name].lower) }
 
-    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: false, allow_blank: true}
 
     has_many :return_authorizations
 

data/app/models/spree/role.rb

@@ -7,7 +7,7 @@ module Spree
     has_many :role_permissions, dependent: :destroy
     has_many :permission_sets, through: :role_permissions
 
-    validates :name, presence: true, uniqueness: { case_sensitive: true, allow_blank: true }
+    validates :name, presence: true, uniqueness: {case_sensitive: true, allow_blank: true}
 
     def admin?
       name == "admin"

data/app/models/spree/role_user.rb

@@ -8,7 +8,7 @@ module Spree
 
     after_create :auto_generate_spree_api_key
 
-    validates :role_id, uniqueness: { scope: :user_id }
+    validates :role_id, uniqueness: {scope: :user_id}
 
     private
 

data/app/models/spree/shipment.rb

@@ -6,12 +6,12 @@ module Spree
   class Shipment < Spree::Base
     include Metadata
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments, optional: true
-    belongs_to :stock_location, class_name: 'Spree::StockLocation', optional: true
+    belongs_to :order, class_name: "Spree::Order", touch: true, inverse_of: :shipments, optional: true
+    belongs_to :stock_location, class_name: "Spree::StockLocation", optional: true
 
     has_many :adjustments, as: :adjustable, inverse_of: :adjustable, dependent: :delete_all, autosave: true
     has_many :inventory_units, dependent: :destroy, inverse_of: :shipment
-    has_many :shipping_rates, -> { order(:cost) }, dependent: :destroy, inverse_of: :shipment
+    has_many :shipping_rates, -> { order(:cost) }, dependent: :destroy, inverse_of: :shipment, autosave: true
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
     has_many :cartons, -> { distinct }, through: :inventory_units
@@ -27,11 +27,11 @@ module Spree
 
     accepts_nested_attributes_for :inventory_units
 
-    make_permalink field: :number, length: 11, prefix: 'H'
+    make_permalink field: :number, length: 11, prefix: "H"
 
-    scope :pending, -> { with_state('pending') }
-    scope :ready,   -> { with_state('ready') }
-    scope :shipped, -> { with_state('shipped') }
+    scope :pending, -> { with_state("pending") }
+    scope :ready, -> { with_state("ready") }
+    scope :shipped, -> { with_state("shipped") }
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
     scope :with_state, ->(*state) { where(state:) }
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
@@ -43,8 +43,8 @@ module Spree
 
     include ::Spree::Config.state_machines.shipment
 
-    self.allowed_ransackable_associations = ['order']
-    self.allowed_ransackable_attributes = ['number']
+    self.allowed_ransackable_associations = ["order"]
+    self.allowed_ransackable_attributes = ["number"]
 
     delegate :tax_category, :tax_category_id, to: :selected_shipping_rate, allow_nil: true
 
@@ -63,9 +63,10 @@ module Spree
     end
 
     extend DisplayMoney
+
     money_methods(
       :cost, :amount, :item_cost,
-      :total, :total_before_tax,
+      :total, :total_before_tax
     )
     alias_attribute :amount, :cost
 
@@ -151,7 +152,7 @@ module Spree
       # If one of the new rates matches the previously selected shipping
       # method, select that instead of the default provided by the estimator.
       # Otherwise, keep the default.
-      selected_rate = new_rates.detect{ |rate| rate.shipping_method_id == original_shipping_method_id }
+      selected_rate = new_rates.detect { |rate| rate.shipping_method_id == original_shipping_method_id }
       if selected_rate
         new_rates.each do |rate|
           rate.selected = (rate == selected_rate)
@@ -195,7 +196,7 @@ module Spree
       end
 
       transaction do
-        selected_shipping_rate.update!(selected: false) if selected_shipping_rate
+        selected_shipping_rate&.update!(selected: false)
         new_rate.update!(selected: true)
       end
     end
@@ -203,13 +204,13 @@ module Spree
     def determine_state(order)
       Spree.deprecator.warn "Use Spree::Shipment#recalculate_state instead"
 
-      return 'shipped' if shipped?
-      return 'canceled' if order.canceled? || inventory_units.all?(&:canceled?)
-      return 'pending' unless order.can_ship?
+      return "shipped" if shipped?
+      return "canceled" if order.canceled? || inventory_units.all?(&:canceled?)
+      return "pending" unless order.can_ship?
       if can_transition_from_pending_to_ready?
-        'ready'
+        "ready"
       else
-        'pending'
+        "pending"
       end
     end
 
@@ -243,7 +244,7 @@ module Spree
     end
 
     def shipped=(value)
-      return unless value == '1' && shipped_at.nil?
+      return unless value == "1" && shipped_at.nil?
       self.shipped_at = Time.current
     end
 
@@ -278,14 +279,21 @@ module Spree
     end
 
     def update_amounts
-      if selected_shipping_rate
-        self.cost = selected_shipping_rate.cost
-        if changed?
-          update_columns(
-            cost:,
-            updated_at: Time.current
-          )
-        end
+      assign_amounts
+      persist_amounts
+    end
+
+    def assign_amounts
+      return unless selected_shipping_rate
+      self.cost = selected_shipping_rate.cost
+    end
+
+    def persist_amounts
+      if cost_changed?
+        update_columns(
+          cost:,
+          updated_at: Time.current
+        )
       end
     end
 
@@ -312,7 +320,7 @@ module Spree
       new_state = recalculate_state
       if new_state != old_state
         update_columns state: new_state, updated_at: Time.current
-        after_ship if new_state == 'shipped'
+        after_ship if new_state == "shipped"
       end
     end
 
@@ -332,12 +340,12 @@ module Spree
     end
 
     def can_get_rates?
-      order.ship_address && order.ship_address.valid?
+      order.ship_address&.valid?
     end
 
     def manifest_restock(item)
       if item.states["on_hand"].to_i > 0
-       stock_location.restock item.variant, item.states["on_hand"], self
+        stock_location.restock item.variant, item.states["on_hand"], self
       end
 
       if item.states["backordered"].to_i > 0