solidus_core 2.9.0 → 2.10.0

data/app/models/spree/promotion.rb

@@ -7,7 +7,7 @@ module Spree
 
     attr_reader :eligibility_errors
 
-    belongs_to :promotion_category
+    belongs_to :promotion_category, optional: true
 
     has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :rules, :promotion_rules
@@ -126,9 +126,12 @@ module Spree
     # called anytime order.recalculate happens
     def eligible?(promotable, promotion_code: nil)
       return false if inactive?
-      return false if usage_limit_exceeded?
-      return false if promotion_code && promotion_code.usage_limit_exceeded?
       return false if blacklisted?(promotable)
+
+      excluded_orders = eligibility_excluded_orders(promotable)
+      return false if usage_limit_exceeded?(excluded_orders: excluded_orders)
+      return false if promotion_code&.usage_limit_exceeded?(excluded_orders: excluded_orders)
+
       !!eligible_rules(promotable, {})
     end
 
@@ -138,7 +141,8 @@ module Spree
     def eligible_rules(promotable, options = {})
       # Promotions without rules are eligible by default.
       return [] if rules.none?
-      eligible = lambda { |r| r.eligible?(promotable, options) }
+
+      eligible = lambda { |rule| rule.eligible?(promotable, options) }
       specific_rules = rules.for(promotable)
       return [] if specific_rules.none?
 
@@ -165,23 +169,23 @@ module Spree
 
     # Whether the promotion has exceeded it's usage restrictions.
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
     # @return true or false
-    def usage_limit_exceeded?
+    def usage_limit_exceeded?(excluded_orders: [])
       if usage_limit
-        usage_count >= usage_limit
+        usage_count(excluded_orders: excluded_orders) >= usage_limit
       end
     end
 
     # Number of times the code has been used overall
     #
+    # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
     # @return [Integer] usage count
-    def usage_count
-      Spree::Adjustment.eligible.
-        promotion.
-        where(source_id: actions.map(&:id)).
-        joins(:order).
-        merge(Spree::Order.complete).
-        distinct.
+    def usage_count(excluded_orders: [])
+      Spree::Adjustment.promotion.
+        eligible.
+        in_completed_orders(excluded_orders: excluded_orders).
+        where(source_id: actions).
         count(:order_id)
     end
 
@@ -255,8 +259,19 @@ module Spree
 
     def apply_automatically_disallowed_with_codes_or_paths
       return unless apply_automatically
+
       errors.add(:apply_automatically, :disallowed_with_code) if codes.any?
       errors.add(:apply_automatically, :disallowed_with_path) if path.present?
     end
+
+    def eligibility_excluded_orders(promotable)
+      if promotable.is_a?(Spree::Order)
+        [promotable]
+      elsif promotable.respond_to?(:order)
+        [promotable.order]
+      else
+        []
+      end
+    end
   end
 end

data/app/models/spree/promotion_action.rb

@@ -14,9 +14,9 @@ module Spree
     include Discard::Model
     self.discard_column = :deleted_at
 
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
-    scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
+    scope :of_type, ->(type) { where(type: Array.wrap(type).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }
 
     # Updates the state of the order or performs some other action depending on

data/app/models/spree/promotion_chooser.rb

@@ -26,8 +26,8 @@ module Spree
 
     # @return The best promotion from this set of adjustments.
     def best_promotion_adjustment
-      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|
-        [a.amount, -a.id]
+      @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |adjustment|
+        [adjustment.amount, -adjustment.id]
       end
     end
   end

data/app/models/spree/promotion_code/batch_builder.rb

@@ -33,12 +33,12 @@ class ::Spree::PromotionCode::BatchBuilder
   def build_promotion_codes
     generate_random_codes
     promotion_code_batch.update!(state: "completed")
-  rescue StandardError => e
+  rescue StandardError => error
     promotion_code_batch.update!(
-      error: e.inspect,
+      error: error.inspect,
       state: "failed"
     )
-    raise e
+    raise error
   end
 
   private

data/app/models/spree/promotion_code.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Spree::PromotionCode < Spree::Base
-  belongs_to :promotion, inverse_of: :codes
-  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
+  belongs_to :promotion, inverse_of: :codes, optional: true
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch", optional: true
   has_many :adjustments
 
   validates :value, presence: true, uniqueness: { allow_blank: true }
@@ -14,22 +14,23 @@ class Spree::PromotionCode < Spree::Base
 
   # Whether the promotion code has exceeded its usage restrictions
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage limit
   # @return true or false
-  def usage_limit_exceeded?
+  def usage_limit_exceeded?(excluded_orders: [])
     if usage_limit
-      usage_count >= usage_limit
+      usage_count(excluded_orders: excluded_orders) >= usage_limit
     end
   end
 
   # Number of times the code has been used overall
   #
+  # @param excluded_orders [Array<Spree::Order>] Orders to exclude from usage count
   # @return [Integer] usage count
-  def usage_count
-    adjustments.eligible.
-      joins(:order).
-      merge(Spree::Order.complete).
-      distinct.
-      count(:order_id)
+  def usage_count(excluded_orders: [])
+    adjustments.
+    eligible.
+    in_completed_orders(excluded_orders: excluded_orders).
+    count(:order_id)
   end
 
   def usage_limit

data/app/models/spree/promotion_code_batch.rb

@@ -5,7 +5,7 @@ module Spree
     class CantProcessStartedBatch < StandardError
     end
 
-    belongs_to :promotion, class_name: "Spree::Promotion"
+    belongs_to :promotion, class_name: "Spree::Promotion", optional: true
     has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
 
     validates :number_of_codes, numericality: { greater_than: 0 }

data/app/models/spree/promotion_rule.rb

@@ -3,9 +3,9 @@
 module Spree
   # Base class for all promotion rules
   class PromotionRule < Spree::Base
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
-    scope :of_type, ->(t) { where(type: t) }
+    scope :of_type, ->(type) { where(type: type) }
 
     validates :promotion, presence: true
     validate :unique_per_promotion, on: :create

data/app/models/spree/promotion_rule_role.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleRole < ActiveRecord::Base
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :role, class_name: 'Spree::Role'
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :role, class_name: 'Spree::Role', optional: true
   end
 end

data/app/models/spree/promotion_rule_store.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleStore < Spree::Base
     self.table_name = "spree_promotion_rules_stores"
 
-    belongs_to :promotion_rule, class_name: "Spree::PromotionRule"
-    belongs_to :store, class_name: "Spree::Store"
+    belongs_to :promotion_rule, class_name: "Spree::PromotionRule", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
   end
 end

data/app/models/spree/promotion_rule_taxon.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleTaxon < Spree::Base
-    belongs_to :promotion_rule
-    belongs_to :taxon
+    belongs_to :promotion_rule, optional: true
+    belongs_to :taxon, optional: true
   end
 end

data/app/models/spree/promotion_rule_user.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleUser < Spree::Base
     self.table_name = 'spree_promotion_rules_users'
 
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
   end
 end

data/app/models/spree/refund.rb

@@ -2,9 +2,9 @@
 
 module Spree
   class Refund < Spree::Base
-    belongs_to :payment, inverse_of: :refunds
-    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
-    belongs_to :reimbursement, inverse_of: :refunds
+    belongs_to :payment, inverse_of: :refunds, 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
 
@@ -68,8 +68,8 @@ module Spree
       end
 
       response
-    rescue ActiveMerchant::ConnectionError => e
-      logger.error(I18n.t('spree.gateway_error') + "  #{e.inspect}")
+    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'))
     end
 

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

@@ -6,8 +6,8 @@ module Spree
       class_attribute :default_creditable_class
       self.default_creditable_class = Spree::StoreCredit
 
-      belongs_to :reimbursement, inverse_of: :credits
-      belongs_to :creditable, polymorphic: true
+      belongs_to :reimbursement, inverse_of: :credits, optional: true
+      belongs_to :creditable, polymorphic: true, optional: true
 
       validates :creditable, presence: true
 

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

@@ -18,7 +18,7 @@ module Spree
 
     def initialize(return_items)
       @return_items = return_items
-      @reimbursement_type_hash = Hash.new { |h, k| h[k] = [] }
+      @reimbursement_type_hash = Hash.new { |hash, key| hash[key] = [] }
     end
 
     def calculate_reimbursement_types

data/app/models/spree/reimbursement.rb

@@ -4,8 +4,8 @@ module Spree
   class Reimbursement < Spree::Base
     class IncompleteReimbursementError < StandardError; end
 
-    belongs_to :order, inverse_of: :reimbursements
-    belongs_to :customer_return, inverse_of: :reimbursements, touch: true
+    belongs_to :order, inverse_of: :reimbursements, optional: true
+    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'
@@ -59,15 +59,7 @@ module Spree
     class_attribute :reimbursement_failure_hooks
     self.reimbursement_failure_hooks = []
 
-    state_machine :reimbursement_status, initial: :pending do
-      event :errored do
-        transition to: :errored, from: [:pending, :errored]
-      end
-
-      event :reimbursed do
-        transition to: :reimbursed, from: [:pending, :errored]
-      end
-    end
+    include ::Spree::Config.state_machines.reimbursement
 
     class << self
       def build_from_customer_return(customer_return)
@@ -112,11 +104,11 @@ module Spree
       if unpaid_amount_within_tolerance?
         reimbursed!
         Spree::Event.fire 'reimbursement_reimbursed', reimbursement: self
-        reimbursement_success_hooks.each { |h| h.call self }
+        reimbursement_success_hooks.each { |hook| hook.call self }
       else
         errored!
         Spree::Event.fire 'reimbursement_errored', reimbursement: self
-        reimbursement_failure_hooks.each { |h| h.call self }
+        reimbursement_failure_hooks.each { |hook| hook.call self }
       end
 
       if errored?

data/app/models/spree/reimbursement_tax_calculator.rb

@@ -25,7 +25,7 @@ module Spree
         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
 
-        return_item.update_attributes!({
+        return_item.update!({
           additional_tax_total: additional_tax_total,
           included_tax_total:   included_tax_total
         })

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

@@ -63,8 +63,8 @@ module Spree
 
     def sorted_eligible_refund_payments(payments)
       if eligible_refund_methods = self.eligible_refund_methods
-        payments = payments.select { |p| eligible_refund_methods.include? p.payment_method.class }
-        payments = payments.sort_by { |p| eligible_refund_methods.index(p.payment_method.class) }
+        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
       payments
     end

data/app/models/spree/return_authorization.rb

@@ -4,14 +4,14 @@ module Spree
   # Models the return of Inventory Units to a Stock Location for an Order.
   #
   class ReturnAuthorization < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
+    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
-    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id
+    belongs_to :stock_location, optional: true
+    belongs_to :reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id, optional: true
 
     before_create :generate_number
 
@@ -22,13 +22,7 @@ module Spree
     validate :must_have_shipped_units, on: :create
     validate :no_previously_exchanged_inventory_units, on: :create
 
-    state_machine initial: :authorized do
-      before_transition to: :canceled, do: :cancel_return_items
-
-      event :cancel do
-        transition to: :canceled, from: :authorized, if: lambda { |return_authorization| return_authorization.can_cancel_return_items? }
-      end
-    end
+    include ::Spree::Config.state_machines.return_authorization
 
     extend DisplayMoney
     money_methods :pre_tax_total, :amount, :total_excluding_vat

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

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

data/app/models/spree/return_item.rb

@@ -29,15 +29,15 @@ module Spree
     class_attribute :refund_amount_calculator
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
-    belongs_to :return_authorization, inverse_of: :return_items
-    belongs_to :inventory_unit, inverse_of: :return_items
-    belongs_to :exchange_variant, class_name: 'Spree::Variant'
-    belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
-    belongs_to :customer_return, inverse_of: :return_items
-    belongs_to :reimbursement, inverse_of: :return_items
-    belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
-    belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
-    belongs_to :return_reason, class_name: 'Spree::ReturnReason', foreign_key: :return_reason_id
+    belongs_to :return_authorization, inverse_of: :return_items, optional: true
+    belongs_to :inventory_unit, inverse_of: :return_items, 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
 
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
@@ -77,22 +77,8 @@ module Spree
     before_create :set_default_amount, unless: :amount_changed?
     before_save :set_exchange_amount
 
-    state_machine :reception_status, initial: :awaiting do
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :attempt_accept
-      after_transition to: COMPLETED_RECEPTION_STATUSES,  do: :check_unexchange
-      after_transition to: :received, do: :process_inventory_unit!
-
-      event(:cancel) { transition to: :cancelled, from: :awaiting }
-
-      event(:receive) { transition to: :received, from: INTERMEDIATE_RECEPTION_STATUSES + [:awaiting] }
-      event(:unexchange) { transition to: :unexchanged, from: [:awaiting] }
-      event(:give) { transition to: :given_to_customer, from: :awaiting }
-      event(:lost) { transition to: :lost_in_transit, from: :awaiting }
-      event(:wrong_item_shipped) { transition to: :shipped_wrong_item, from: :awaiting }
-      event(:short_shipped) { transition to: :short_shipped, from: :awaiting }
-      event(:in_transit) { transition to: :in_transit, from: :awaiting }
-      event(:expired) { transition to: :expired, from: :awaiting }
-    end
+    include ::Spree::Config.state_machines.return_item_reception
+    include ::Spree::Config.state_machines.return_item_acceptance
 
     extend DisplayMoney
     money_methods :pre_tax_amount, :amount, :total, :total_excluding_vat
@@ -104,31 +90,6 @@ module Spree
       COMPLETED_RECEPTION_STATUSES.map(&:to_s).include?(reception_status.to_s)
     end
 
-    state_machine :acceptance_status, initial: :pending do
-      event :attempt_accept do
-        transition to: :accepted, from: :accepted
-        transition to: :accepted, from: :pending, if: ->(return_item) { return_item.eligible_for_return? }
-        transition to: :manual_intervention_required, from: :pending, if: ->(return_item) { return_item.requires_manual_intervention? }
-        transition to: :rejected, from: :pending
-      end
-
-      # bypasses eligibility checks
-      event :accept do
-        transition to: :accepted, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :reject do
-        transition to: :rejected, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      # bypasses eligibility checks
-      event :require_manual_intervention do
-        transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
-      end
-
-      after_transition any => any, do: :persist_acceptance_status_errors
-    end
 
     attr_accessor :skip_customer_return_processing
 
@@ -214,7 +175,7 @@ module Spree
       event_paths.delete(:expired)
       event_paths.delete(:unexchange)
 
-      status_paths.map{ |s| I18n.t("spree.reception_states.#{s}", default: s.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?
@@ -226,7 +187,7 @@ module Spree
     private
 
     def persist_acceptance_status_errors
-      update_attributes(acceptance_status_errors: validator.errors)
+      update(acceptance_status_errors: validator.errors)
     end
 
     def currency

data/app/models/spree/role_user.rb

@@ -3,8 +3,8 @@
 module Spree
   class RoleUser < Spree::Base
     self.table_name = "spree_roles_users"
-    belongs_to :role, class_name: "Spree::Role"
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :role, class_name: "Spree::Role", optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
 
     after_create :auto_generate_spree_api_key
 

data/app/models/spree/shipment.rb

@@ -4,8 +4,8 @@ module Spree
   # An order's planned shipments including tracking and cost.
   #
   class Shipment < Spree::Base
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
-    belongs_to :stock_location, class_name: 'Spree::StockLocation'
+    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
     has_many :inventory_units, dependent: :destroy, inverse_of: :shipment
@@ -31,7 +31,7 @@ module Spree
     scope :ready,   -> { with_state('ready') }
     scope :shipped, -> { with_state('shipped') }
     scope :trackable, -> { where("tracking IS NOT NULL AND tracking != ''") }
-    scope :with_state, ->(*s) { where(state: s) }
+    scope :with_state, ->(*state) { where(state: state) }
     # sort by most recent shipped_at, falling back to created_at. add "id desc" to make specs that involve this scope more deterministic.
     scope :reverse_chronological, -> {
       order(Arel.sql("coalesce(#{Spree::Shipment.table_name}.shipped_at, #{Spree::Shipment.table_name}.created_at) desc"), id: :desc)
@@ -39,41 +39,7 @@ module Spree
 
     scope :by_store, ->(store) { joins(:order).merge(Spree::Order.by_store(store)) }
 
-    # shipment state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine initial: :pending, use_transactions: false do
-      event :ready do
-        transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
-        transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
-      end
-
-      event :pend do
-        transition from: :ready, to: :pending
-      end
-
-      event :ship do
-        transition from: [:ready, :canceled], to: :shipped
-      end
-      after_transition to: :shipped, do: :after_ship
-
-      event :cancel do
-        transition to: :canceled, from: [:pending, :ready]
-      end
-      after_transition to: :canceled, do: :after_cancel
-
-      event :resume do
-        transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
-        transition from: :canceled, to: :pending
-      end
-      after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
-
-      after_transition do |shipment, transition|
-        shipment.state_changes.create!(
-          previous_state: transition.from,
-          next_state:     transition.to,
-          name:           'shipment'
-        )
-      end
-    end
+    include ::Spree::Config.state_machines.shipment
 
     self.whitelisted_ransackable_associations = ['order']
     self.whitelisted_ransackable_attributes = ['number']
@@ -142,7 +108,7 @@ module Spree
     # @return [BigDecimal] the amount of this item, taking into consideration
     #   all non-tax adjustments.
     def total_before_tax
-      amount + adjustments.select { |a| !a.tax? && a.eligible? }.sum(&:amount)
+      amount + adjustments.select { |adjustment| !adjustment.tax? && adjustment.eligible? }.sum(&:amount)
     end
 
     # @return [BigDecimal] the amount of this shipment before VAT tax
@@ -219,7 +185,7 @@ module Spree
     def select_shipping_method(shipping_method)
       estimator = Spree::Config.stock.estimator_class.new
       rates = estimator.shipping_rates(to_package, false)
-      rate = rates.detect { |r| r.shipping_method_id == shipping_method.id }
+      rate = rates.detect { |detected| detected.shipping_method_id == shipping_method.id }
       rate.selected = true
       self.shipping_rates = [rate]
     end
@@ -326,7 +292,7 @@ module Spree
 
     # Update Shipment and make sure Order states follow the shipment changes
     def update_attributes_and_order(params = {})
-      if update_attributes params
+      if update(params)
         if params.key? :selected_shipping_rate_id
           # Changing the selected Shipping Rate won't update the cost (for now)
           # so we persist the Shipment#cost before running `order.recalculate`

data/app/models/spree/shipping_calculator.rb

@@ -2,10 +2,6 @@
 
 module Spree
   class ShippingCalculator < Calculator
-    def compute_shipment(_shipment)
-      raise NotImplementedError, "Please implement 'compute_shipment(shipment)' in your calculator: #{self.class.name}"
-    end
-
     def compute_package(_package)
       raise NotImplementedError, "Please implement 'compute_package(package)' in your calculator: #{self.class.name}"
     end

data/app/models/spree/shipping_manifest.rb

@@ -21,9 +21,9 @@ class Spree::ShippingManifest
         states = {}
         units.group_by(&:state).each { |state, iu| states[state] = iu.count }
 
-        line_item = units.first.line_item
-        variant = units.first.variant
-        ManifestItem.new(line_item, variant, units.length, states)
+        first_unit = units.first
+
+        ManifestItem.new(first_unit.line_item, first_unit.variant, units.length, states)
       end
     end.flatten
   end

data/app/models/spree/shipping_method.rb

@@ -28,7 +28,7 @@ module Spree
     has_many :shipping_method_zones, dependent: :destroy
     has_many :zones, through: :shipping_method_zones
 
-    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory'
+    belongs_to :tax_category, -> { with_deleted }, class_name: 'Spree::TaxCategory', optional: true
     has_many :shipping_method_stock_locations, dependent: :destroy, class_name: "Spree::ShippingMethodStockLocation"
     has_many :stock_locations, through: :shipping_method_stock_locations
 
@@ -41,7 +41,7 @@ module Spree
 
     scope :available_to_store, ->(store) do
       raise ArgumentError, "You must provide a store" if store.nil?
-      store.shipping_methods.empty? ? all : where(id: store.shipping_method_ids)
+      store.shipping_methods.empty? ? all : where(id: store.shipping_methods.ids)
     end
 
     # @param shipping_category_ids [Array<Integer>] ids of desired shipping categories

data/app/models/spree/shipping_method_category.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ShippingMethodCategory < Spree::Base
-    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories
+    belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', optional: true
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :shipping_method_categories, optional: true
   end
 end