spree_core 3.1.14 → 3.2.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b616dbd62252630f0b40acab66132e48cc8b3af
-  data.tar.gz: b24415aa814427cf8ed1e327f759ac924fd5e78f
+  metadata.gz: dc8d21681bc73e110e3d6e705da11f3dc39a53c0
+  data.tar.gz: 9de82bfd2ca0d7c423c39cce5eab7efe902dfc58
 SHA512:
-  metadata.gz: d83a80bcca05c8fdc4fd312caed0e97f7b8b29e2e2ce008525f03ff21e51cd116f33a6ceb34f4c51692200aa2cbb99f5f5c997df12a07233c891f2260a925db4
-  data.tar.gz: 18d88ed67e8b08c6f9564f3bfe56ed7bb16a6330a8e75e25951a874f399620fd23860257c6e469055a9090d20b2ef17c1766785dd919a48733fa64dd95ea66f6
+  metadata.gz: aef6254d9ac18a5e56f5e4df41f2e024ad5a8d49ad8995781fd44f88a034fb2426e9f8de1c81dfb7dbe8720420b81eb4be3528cccaf084c0cce8bd7d401a3fee
+  data.tar.gz: f7136d7ae86448f2a66b85a6b323b3536a9f474489ec8a3d36aac2e892d818b4153a22d0f24147a997aae21157c473dd6fad21e085061c2c8dedc539af15a07a

data/app/assets/javascripts/{spree.js.coffee.erb → spree.js.coffee}

@@ -8,10 +8,10 @@ class window.Spree
       callback(jQuery)
 
   @mountedAt: ->
-    "<%= Rails.application.routes.url_helpers.spree_path(trailing_slash: true) %>"
+    window.SpreePaths.mounted_at
 
   @adminPath: ->
-    '<%= Spree.admin_path.gsub(/\A(\/)?(.*[^\/])(\/)?\z/, '\\2/') %>'
+    window.SpreePaths.admin
 
   @pathFor: (path) ->
     locationOrigin = "#{window.location.protocol}//#{window.location.hostname}" + (if window.location.port then ":#{window.location.port}" else "")

data/app/helpers/spree/base_helper.rb

@@ -41,7 +41,7 @@ module Spree
       object = instance_variable_get('@'+controller_name.singularize)
       meta = {}
 
-      if object.kind_of? ActiveRecord::Base
+      if object.kind_of? ApplicationRecord
         meta[:keywords] = object.meta_keywords if object[:meta_keywords].present?
         meta[:description] = object.meta_description if object[:meta_description].present?
       end

data/app/helpers/spree/products_helper.rb

@@ -38,12 +38,6 @@ module Spree
       description.blank? ? Spree.t(:product_has_no_description) : raw(description)
     end
 
-    def line_item_description(variant)
-      ActiveSupport::Deprecation.warn "line_item_description(variant) is deprecated and may be removed from future releases, use line_item_description_text(line_item.description) instead.", caller
-
-      line_item_description_text(variant.product.description)
-    end
-
     def line_item_description_text description_text
       if description_text.present?
         truncate(strip_tags(description_text.gsub(' ', ' ').squish), length: 100)

data/app/mailers/spree/reimbursement_mailer.rb

@@ -1,10 +1,10 @@
 module Spree
   class ReimbursementMailer < BaseMailer
-      def reimbursement_email(reimbursement, resend = false)
-        @reimbursement = reimbursement.respond_to?(:id) ? reimbursement : Spree::Reimbursement.find(reimbursement)
-        subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
-        subject += "#{Spree::Store.current.name} #{Spree.t('reimbursement_mailer.reimbursement_email.subject')} ##{@reimbursement.order.number}"
-        mail(to: @reimbursement.order.email, from: from_address, subject: subject)
-      end
+    def reimbursement_email(reimbursement, resend = false)
+      @reimbursement = reimbursement.respond_to?(:id) ? reimbursement : Spree::Reimbursement.find(reimbursement)
+      subject = (resend ? "[#{Spree.t(:resend).upcase}] " : '')
+      subject += "#{Spree::Store.current.name} #{Spree.t('reimbursement_mailer.reimbursement_email.subject')} ##{@reimbursement.order.number}"
+      mail(to: @reimbursement.order.email, from: from_address, subject: subject)
+    end
   end
 end

data/app/models/concerns/spree/acts_as_taggable.rb

@@ -0,0 +1,11 @@
+module Spree
+  module ActsAsTaggable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_taggable
+      Spree::PermittedAttributes.send("#{model_name.param_key}_attributes") <<
+        [:tag_list]
+    end
+  end
+end

data/app/models/concerns/spree/adjustment_source.rb

@@ -9,7 +9,7 @@ module Spree
 
     protected
 
-    def create_adjustment(order, adjustable, included = false)
+    def create_adjustment(order, adjustable, included = nil)
       amount = compute_amount(adjustable)
       return if amount == 0
       adjustments.new(order: order,

data/app/models/concerns/spree/ransackable_attributes.rb

@@ -3,7 +3,6 @@ module Spree::RansackableAttributes
   included do
     class_attribute :whitelisted_ransackable_associations
     class_attribute :whitelisted_ransackable_attributes
-    class_attribute :whitelisted_ransackable_scopes
 
     class_attribute :default_ransackable_attributes
     self.default_ransackable_attributes = %w[id name updated_at created_at]
@@ -15,10 +14,6 @@ module Spree::RansackableAttributes
     def self.ransackable_attributes(*args)
       self.default_ransackable_attributes | (self.whitelisted_ransackable_attributes || [])
     end
-
-    def self.ransackable_scopes(*args)
-      whitelisted_ransackable_scopes || []
-    end
   end
 
 end

data/app/models/spree/address.rb

@@ -2,11 +2,21 @@ module Spree
   class Address < Spree::Base
     require 'twitter_cldr'
 
+    NO_ZIPCODE_ISO_CODES ||= [
+      'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
+      'CD', 'CK', 'CUW', 'CI', 'DJ', 'DM', 'GQ', 'ER', 'FJ', 'TF', 'GAB', 'GM', 'GH', 'GD', 'GN',
+      'GY', 'HK', 'IE', 'KI', 'KP', 'LY', 'MO', 'MW', 'ML', 'MR', 'NR', 'AN', 'NU', 'KP', 'PA',
+      'QA', 'RW', 'KN', 'LC', 'ST', 'SC', 'SL', 'SB', 'SO', 'SR', 'SY', 'TZ', 'TL', 'TK', 'TG',
+      'TO', 'TV', 'UG', 'AE', 'VU', 'YE', 'ZW'
+    ].freeze
+
     belongs_to :country, class_name: "Spree::Country"
     belongs_to :state, class_name: "Spree::State"
 
     has_many :shipments, inverse_of: :address
 
+    before_validation :clear_invalid_state_entities, if: -> { country.present? }, on: :update
+
     with_options presence: true do
       validates :firstname, :lastname, :address1, :city, :country
       validates :zipcode, if: :require_zipcode?
@@ -93,53 +103,72 @@ module Spree
     end
 
     def require_zipcode?
-      true
+      country ? country.zipcode_required? : true
     end
 
     private
-      def state_validate
-        # Skip state validation without country (also required)
-        # or when disabled by preference
-        return if country.blank? || !Spree::Config[:address_requires_state]
-        return unless country.states_required
-
-        # ensure associated state belongs to country
-        if state.present?
-          if state.country == country
-            self.state_name = nil #not required as we have a valid state and country combo
-          else
-            if state_name.present?
-              self.state = nil
-            else
-              errors.add(:state, :invalid)
-            end
-          end
+
+    def clear_state_entities
+      clear_state
+      clear_state_name
+    end
+
+    def clear_state
+      self.state = nil
+    end
+
+    def clear_state_name
+      self.state_name = nil
+    end
+
+    def clear_invalid_state_entities
+      if state.present? && (state.country != country)
+        clear_state
+      elsif state_name.present? && !country.states_required? && country.states.empty?
+        clear_state_name
+      end
+    end
+
+    def state_validate
+      # Skip state validation without country (also required)
+      # or when disabled by preference
+      return if country.blank? || !Spree::Config[:address_requires_state]
+      return unless country.states_required
+      # ensure associated state belongs to country
+      if state.present?
+        if state.country == country
+          clear_state_name # not required as we have a valid state and country combo
+        elsif state_name.present?
+          clear_state
+        else
+          errors.add(:state, :invalid)
         end
+      end
+
+      # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+      if state_name.present?
+        if country.states.present?
+          states = country.states.find_all_by_name_or_abbr(state_name)
 
-        # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
-        if state_name.present?
-          if country.states.present?
-            states = country.states.find_all_by_name_or_abbr(state_name)
-
-            if states.size == 1
-              self.state = states.first
-              self.state_name = nil
-            else
-              errors.add(:state, :invalid)
-            end
+          if states.size == 1
+            self.state = states.first
+            clear_state_name
+          else
+            errors.add(:state, :invalid)
           end
         end
-
-        # ensure at least one state field is populated
-        errors.add :state, :blank if state.blank? && state_name.blank?
       end
 
-      def postal_code_validate
-        return if country.blank? || country.iso.blank? || !require_zipcode?
-        return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
+      # ensure at least one state field is populated
+      errors.add :state, :blank if state.blank? && state_name.blank?
+    end
 
-        postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
-        errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s.strip)
-      end
+    def postal_code_validate
+      return if country.blank? || country.iso.blank? || !require_zipcode?
+      return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
+
+      postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
+      errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s.strip)
+    end
   end
 end

data/app/models/spree/app_configuration.rb

@@ -21,14 +21,21 @@ module Spree
   class AppConfiguration < Preferences::Configuration
     # Alphabetized to more easily lookup particular preferences
     preference :address_requires_state, :boolean, default: true # should state/state_name be required
-    preference :admin_interface_logo, :string, default: 'logo/spree_50.png'
+    preference :admin_interface_logo, :string, default: 'admin/logo.png'
     preference :admin_path, :string, default: '/admin'
-    preference :admin_products_per_page, :integer, default: 10
+    preference :admin_products_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_orders_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_properties_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_promotions_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_customer_returns_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_users_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_show_version, :boolean, default: true
     preference :allow_checkout_on_gateway_error, :boolean, default: false
     preference :allow_guest_checkout, :boolean, default: true
     preference :alternative_shipping_phone, :boolean, default: false # Request extra phone for ship addr
     preference :always_include_confirm_step, :boolean, default: false # Ensures confirmation step is always in checkout_progress bar, but does not force a confirm step if your payment methods do not support it.
     preference :always_put_site_name_in_title, :boolean, default: true
+    preference :title_site_name_separator, :string, default: '-' # When always_put_site_name_in_title is true, insert a separator character before the site name in the title
     preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
     preference :auto_capture_on_dispatch, :boolean, default: false # Captures payment for each shipment in Shipment#after_ship callback, and makes Shipment.ready when payment authorized.
     preference :binary_inventory_cache, :boolean, default: false # only invalidate product cache when a stock item changes whether it is in_stock
@@ -41,11 +48,7 @@ module Spree
     preference :layout, :string, default: 'spree/layouts/spree_application'
     preference :logo, :string, default: 'logo/spree_50.png'
     preference :max_level_in_taxons_menu, :integer, default: 1 # maximum nesting level in taxons menu
-    preference :orders_per_page, :integer, default: 15
-    preference :properties_per_page, :integer, default: 15
     preference :products_per_page, :integer, default: 12
-    preference :promotions_per_page, :integer, default: 15
-    preference :customer_returns_per_page, :integer, default: 15
     preference :require_master_price, :boolean, default: true
     preference :restock_inventory, :boolean, default: true # Determines if a return item is restocked automatically once it has been received
     preference :return_eligibility_number_of_days, :integer, default: 365

data/app/models/spree/base.rb

@@ -1,4 +1,4 @@
-class Spree::Base < ActiveRecord::Base
+class Spree::Base < ApplicationRecord
   include Spree::Preferences::Preferable
   serialize :preferences, Hash
 

data/app/models/spree/calculator.rb

@@ -1,7 +1,7 @@
 module Spree
   class Calculator < Spree::Base
     # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
-    if ActiveRecord::Base.connected? && connection.table_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
+    if connection.data_source_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
       acts_as_paranoid
     end
 

data/app/models/spree/country.rb

@@ -1,8 +1,11 @@
 module Spree
   class Country < Spree::Base
+    # we need to have this callback before any dependent: :destroy associations
+    # https://github.com/rails/rails/issues/3458
+    before_destroy :ensure_not_default
+
     has_many :states, dependent: :destroy
     has_many :addresses, dependent: :restrict_with_error
-
     has_many :zone_members,
              -> { where(zoneable_type: 'Spree::Country') },
              class_name: 'Spree::ZoneMember',
@@ -11,8 +14,6 @@ module Spree
 
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
 
-    before_destroy :ensure_not_default
-
     validates :name, :iso_name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     def self.default
@@ -33,7 +34,7 @@ module Spree
     def ensure_not_default
       if id.eql?(Spree::Config[:default_country_id])
         errors.add(:base, Spree.t(:default_country_cannot_be_deleted))
-        false
+        throw(:abort)
       end
     end
   end

data/app/models/spree/credit_card.rb

@@ -9,8 +9,8 @@ module Spree
     after_save :ensure_one_default
 
     # As of rails 4.2 string columns always return strings, we can override it on model level.
-    attribute :month, Type::Integer.new
-    attribute :year,  Type::Integer.new
+    attribute :month, ActiveRecord::Type::Integer.new
+    attribute :year,  ActiveRecord::Type::Integer.new
 
     attr_reader :number
     attr_accessor :encrypted_data,
@@ -23,7 +23,7 @@ module Spree
       validates :name, presence: true
     end
 
-    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
     scope :default, -> { where(default: true) }
 
     # needed for some of the ActiveMerchant gateways (eg. SagePay)

data/app/models/spree/gateway/bogus.rb

@@ -21,43 +21,43 @@ module Spree
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
       if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
 
     def authorize(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 
     def credit(money, credit_card, response_code, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def capture(money, authorization, gateway_options)
       if authorization == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
       end
 
     end
 
     def void(response_code, credit_card, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def cancel(_response_code)
@@ -82,8 +82,8 @@ module Spree
         record = true
         prefix = success ? 'BGS' : 'FAIL'
         while record
-          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
-          record = CreditCard.where(:gateway_customer_profile_id => random).first
+          random = "#{ prefix }-#{ Array.new(6) { rand(6) }.join }"
+          record = CreditCard.find_by(gateway_customer_profile_id: random)
         end
         random
       end

data/app/models/spree/gateway/bogus_simple.rb

@@ -8,17 +8,17 @@ module Spree
 
     def authorize(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 

data/app/models/spree/gateway.rb

@@ -17,7 +17,7 @@ module Spree
       gateway_options = options
       gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
       if gateway_options[:server]
-        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+        ActiveMerchant::Billing::Base.mode = gateway_options[:server].to_sym
       end
       @provider ||= provider_class.new(gateway_options)
     end

data/app/models/spree/image.rb

@@ -9,8 +9,8 @@ module Spree
                       path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
                       convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
     validates_attachment :attachment,
-      :presence => true,
-      :content_type => { :content_type => %w(image/jpeg image/jpg image/png image/gif) }
+      presence: true,
+      content_type: { content_type: %w(image/jpeg image/jpg image/png image/gif) }
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet

data/app/models/spree/inventory_unit.rb

@@ -4,7 +4,7 @@ module Spree
     with_options inverse_of: :inventory_units do
       belongs_to :variant, class_name: "Spree::Variant"
       belongs_to :order, class_name: "Spree::Order"
-      belongs_to :shipment, class_name: "Spree::Shipment", touch: true
+      belongs_to :shipment, class_name: "Spree::Shipment", touch: true, optional: true
       belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization"
       belongs_to :line_item, class_name: "Spree::LineItem"
     end
@@ -14,13 +14,14 @@ module Spree
 
     scope :backordered, -> { where state: 'backordered' }
     scope :on_hand, -> { where state: 'on_hand' }
+    scope :on_hand_or_backordered, -> { where state: ['backordered', 'on_hand'] }
     scope :shipped, -> { where state: 'shipped' }
     scope :returned, -> { where state: 'returned' }
     scope :backordered_per_variant, ->(stock_item) do
       includes(:shipment, :order)
-        .where("spree_shipments.state != 'canceled'").references(:shipment)
+        .where.not(spree_shipments: { state: 'canceled' })
         .where(variant_id: stock_item.variant_id)
-        .where('spree_orders.completed_at is not null')
+        .where.not(spree_orders: { completed_at: nil })
         .backordered.order("spree_orders.completed_at ASC")
     end
 
@@ -52,13 +53,8 @@ module Spree
       end
     end
 
-    def self.finalize_units!(inventory_units)
-      inventory_units.map do |iu|
-        iu.update_columns(
-          pending: false,
-          updated_at: Time.current,
-        )
-      end
+    def self.finalize_units!
+      update_all(pending: false, updated_at: Time.current)
     end
 
     def find_stock_item

data/app/models/spree/line_item.rb

@@ -16,14 +16,15 @@ module Spree
     before_validation :copy_price
     before_validation :copy_tax_category
 
-    validates :variant, presence: true
+    validates :variant, :order, presence: true
     validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
     validates :price, numericality: true
 
     validates_with Stock::AvailabilityValidator
-    validate :ensure_proper_currency
+    validate :ensure_proper_currency, if: -> { order.present? }
+
+    before_destroy :verify_order_inventory, if: -> { order.has_checkout_step?("delivery") }
 
-    before_destroy :update_inventory
     before_destroy :destroy_inventory_units
 
     after_save :update_inventory
@@ -31,7 +32,8 @@ module Spree
 
     after_create :update_tax_charge
 
-    delegate :name, :description, :sku, :should_track_inventory?, :product, to: :variant
+    delegate :name, :description, :sku, :should_track_inventory?, :product, :options_text, to: :variant
+    delegate :brand, :category, to: :product
     delegate :tax_zone, to: :order
 
     attr_accessor :target_shipment
@@ -107,6 +109,11 @@ module Spree
       assign_attributes opts
     end
 
+    # Remove variant default_scope `deleted_at: nil`
+    def variant
+      Spree::Variant.unscoped { super }
+    end
+
     private
 
     def ensure_valid_quantity
@@ -126,12 +133,16 @@ module Spree
 
     def update_inventory
       if (changed? || target_shipment.present?) && order.has_checkout_step?("delivery")
-        Spree::OrderInventory.new(order, self).verify(target_shipment)
+        verify_order_inventory
       end
     end
 
+    def verify_order_inventory
+      Spree::OrderInventory.new(order, self).verify(target_shipment)
+    end
+
     def destroy_inventory_units
-      inventory_units.destroy_all
+      throw(:abort) unless inventory_units.destroy_all
     end
 
     def update_adjustments

data/app/models/spree/order/checkout.rb

@@ -62,7 +62,7 @@ module Spree
 
               event :return do
                 transition to: :returned,
-                           from: [:complete, :awaiting_return, :canceled, :returned],
+                           from: [:complete, :awaiting_return, :canceled, :resumed],
                            if: :all_inventory_units_returned?
               end
 
@@ -214,7 +214,7 @@ module Spree
             checkout_step_index(state) > checkout_step_index(self.state)
           end
 
-          define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
+          define_callbacks :updating_from_params
 
           set_callback :updating_from_params, :before, :update_params_payment_source