solidus_core 3.0.0 → 4.5.1

data/app/models/spree/return_item.rb

@@ -30,7 +30,7 @@ module Spree
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
     belongs_to :return_authorization, inverse_of: :return_items, optional: true
-    belongs_to :inventory_unit, 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 :customer_return, inverse_of: :return_items, optional: true
@@ -42,7 +42,6 @@ module Spree
     validate :eligible_exchange_variant
     validate :belongs_to_same_customer_order
     validate :validate_acceptance_status_for_reimbursement
-    validates :inventory_unit, presence: true
     validate :validate_no_other_completed_return_items
 
     after_create :cancel_others, unless: :cancelled?
@@ -54,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') }
@@ -68,7 +67,7 @@ module Spree
     scope :exchange_processed, -> { where.not(exchange_inventory_unit: nil) }
     scope :exchange_required, -> { exchange_requested.where(exchange_inventory_unit: nil) }
 
-    serialize :acceptance_status_errors
+    serialize :acceptance_status_errors, coder: YAML
 
     delegate :eligible_for_return?, :requires_manual_intervention?, to: :validator
     delegate :variant, to: :inventory_unit
@@ -94,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
@@ -131,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
@@ -249,21 +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,
-          return_item_id: other_return_item.id
-        })
+        errors.add(:inventory_unit, :other_completed_return_item_exists,
+          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

data/app/models/spree/return_reason.rb

@@ -2,10 +2,15 @@
 
 module Spree
   class ReturnReason < Spree::Base
-    include Spree::NamedType
+    scope :active, -> { where(active: true) }
+    default_scope -> { order(arel_table[:name].lower) }
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     has_many :return_authorizations
 
+    self.allowed_ransackable_attributes = %w[name]
+
     def self.reasons_for_return_items(return_items)
       # Only allow an inactive reason if it's already associated to a return item
       active | return_items.map(&:return_reason).compact

data/app/models/spree/role.rb

@@ -4,8 +4,10 @@ module Spree
   class Role < Spree::Base
     has_many :role_users, class_name: "Spree::RoleUser", dependent: :destroy
     has_many :users, through: :role_users
+    has_many :role_permissions, dependent: :destroy
+    has_many :permission_sets, through: :role_permissions
 
-    validates_uniqueness_of :name, case_sensitive: true
+    validates :name, presence: true, uniqueness: { case_sensitive: true, allow_blank: true }
 
     def admin?
       name == "admin"

data/app/models/spree/role_permission.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class RolePermission < Spree::Base
+    belongs_to :role
+    belongs_to :permission_set
+  end
+end

data/app/models/spree/shipment.rb

@@ -4,6 +4,8 @@ module Spree
   # An order's planned shipments including tracking and cost.
   #
   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
 
@@ -31,7 +33,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, ->(*state) { where(state: state) }
+    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.
     scope :reverse_chronological, -> {
       order(Arel.sql("coalesce(#{Spree::Shipment.table_name}.shipped_at, #{Spree::Shipment.table_name}.created_at) desc"), id: :desc)
@@ -41,8 +43,8 @@ module Spree
 
     include ::Spree::Config.state_machines.shipment
 
-    self.whitelisted_ransackable_associations = ['order']
-    self.whitelisted_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
 
@@ -92,7 +94,7 @@ module Spree
     # @return [BigDecimal] the amount of this item, taking into consideration
     #   all non-tax adjustments.
     def total_before_tax
-      amount + adjustments.select { |adjustment| !adjustment.tax? && adjustment.eligible? }.sum(&:amount)
+      amount + adjustments.reject(&:tax?).sum(&:amount)
     end
 
     # @return [BigDecimal] the amount of this shipment before VAT tax
@@ -175,7 +177,7 @@ module Spree
     end
 
     def manifest
-      @manifest ||= Spree::ShippingManifest.new(inventory_units: inventory_units).items
+      @manifest ||= Spree::ShippingManifest.new(inventory_units:).items
     end
 
     def selected_shipping_rate_id
@@ -217,7 +219,7 @@ module Spree
 
     def set_up_inventory(state, variant, _order, line_item)
       inventory_units.create(
-        state: state,
+        state:,
         variant_id: variant.id,
         line_item_id: line_item.id
       )
@@ -263,7 +265,7 @@ module Spree
         self.cost = selected_shipping_rate.cost
         if changed?
           update_columns(
-            cost: cost,
+            cost:,
             updated_at: Time.current
           )
         end
@@ -286,7 +288,7 @@ module Spree
 
     # Updates the state of the Shipment bypassing any callbacks.
     #
-    # If this moves the shipmnent to the 'shipped' state, after_ship will be
+    # If this moves the shipment to the 'shipped' state, after_ship will be
     # called.
     def update_state
       old_state = state
@@ -312,7 +314,7 @@ module Spree
     end
 
     def after_ship
-      order.shipping.ship_shipment(self, suppress_mailer: suppress_mailer)
+      order.shipping.ship_shipment(self, suppress_mailer:)
     end
 
     def can_get_rates?
@@ -339,7 +341,7 @@ module Spree
 
     def ensure_can_destroy
       if shipped? || canceled?
-        errors.add(:state, :cannot_destroy, state: state)
+        errors.add(:state, :cannot_destroy, state:)
         throw :abort
       end
     end

data/app/models/spree/shipping_category.rb

@@ -2,6 +2,8 @@
 
 module Spree
   class ShippingCategory < Spree::Base
+    self.allowed_ransackable_attributes = %w[name]
+
     validates :name, presence: true
     has_many :products, inverse_of: :shipping_category
     has_many :shipping_method_categories, inverse_of: :shipping_category

data/app/models/spree/shipping_rate.rb

@@ -18,8 +18,7 @@ module Spree
     delegate :name, :tax_category, :tax_category_id, to: :shipping_method
     delegate :code, to: :shipping_method, prefix: true
     alias_attribute :amount, :cost
-
-    alias_method :total_before_tax, :amount
+    alias_attribute :total_before_tax, :cost
 
     extend DisplayMoney
     money_methods :amount
@@ -32,7 +31,7 @@ module Spree
       tax_explanations = taxes.map(&:label).join(tax_label_separator)
 
       I18n.t 'spree.shipping_rate.display_price.display_price_with_explanations',
-             price: price,
+             price:,
              explanations: tax_explanations
     end
     alias_method :display_cost, :display_price

data/app/models/spree/shipping_rate_tax.rb

@@ -5,7 +5,7 @@ module Spree
   # @attr [Spree::ShippingRate] shipping_rate The shipping rate to be taxed
   # @attr [Spree::TaxRate] tax_rate The tax rate used to calculate the tax amount
   # @since 1.3.0
-  # @see Spree::Tax::ShippingRateTaxer
+  # @see Spree::Stock::Estimator
   class ShippingRateTax < Spree::Base
     belongs_to :shipping_rate, class_name: "Spree::ShippingRate", optional: true
     belongs_to :tax_rate, class_name: "Spree::TaxRate", optional: true

data/app/models/spree/{order_contents.rb → simple_order_contents.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Spree
-  class OrderContents
+  class SimpleOrderContents
     attr_accessor :order
 
     def initialize(order)
@@ -38,12 +38,7 @@ module Spree
       if order.update(params)
         unless order.completed?
           order.line_items = order.line_items.select { |li| li.quantity > 0 }
-          # Update totals, then check if the order is eligible for any cart promotions.
-          # If we do not update first, then the item total will be wrong and ItemTotal
-          # promotion rules would not be triggered.
-          reload_totals
-          PromotionHandler::Cart.new(order).activate
-          order.ensure_updated_shipments
+          order.check_shipments_and_restart_checkout
         end
         reload_totals
         true
@@ -71,10 +66,8 @@ module Spree
     private
 
     def after_add_or_remove(line_item, options = {})
-      reload_totals
       shipment = options[:shipment]
-      shipment.present? ? shipment.update_amounts : order.ensure_updated_shipments
-      PromotionHandler::Cart.new(order, line_item).activate
+      shipment.present? ? shipment.update_amounts : order.check_shipments_and_restart_checkout
       reload_totals
       line_item
     end
@@ -88,11 +81,15 @@ module Spree
 
       line_item ||= order.line_items.new(
         quantity: 0,
-        variant: variant,
+        variant:,
+        adjustments: []
       )
 
+      permitted_attributes = Spree::PermittedAttributes.line_item_attributes.dup
+      permitted_attributes << { admin_metadata: {} } if options[:admin_metadata].present?
+
       line_item.quantity += quantity.to_i
-      line_item.options = ActionController::Parameters.new(options).permit(PermittedAttributes.line_item_attributes).to_h
+      line_item.options = ActionController::Parameters.new(options).permit(permitted_attributes).to_h
 
       line_item.target_shipment = options[:shipment]
       line_item.save!
@@ -116,7 +113,7 @@ module Spree
     def grab_line_item_by_variant(variant, raise_error = false, options = {})
       line_item = order.find_line_item_by_variant(variant, options)
 
-      if !line_item.present? && raise_error
+      if line_item.blank? && raise_error
         raise ActiveRecord::RecordNotFound, "Line item not found for variant #{variant.sku}"
       end
 

data/app/models/spree/state.rb

@@ -15,7 +15,7 @@ module Spree
       )
     end
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
     # blank is added elsewhere, if needed

data/app/models/spree/stock/allocator/on_hand_first.rb

@@ -7,11 +7,11 @@ module Spree
         def allocate_inventory(desired)
           # Allocate any available on hand inventory
           on_hand = allocate_on_hand(desired)
-          desired -= on_hand.values.sum if on_hand.present?
+          desired -= on_hand.values.reduce(&:+) if on_hand.present?
 
           # Allocate remaining desired inventory from backorders
           backordered = allocate_backordered(desired)
-          desired -= backordered.values.sum if backordered.present?
+          desired -= backordered.values.reduce(&:+) if backordered.present?
 
           # If all works at this point desired must be empty
           [on_hand, backordered, desired]

data/app/models/spree/stock/availability.rb

@@ -19,7 +19,7 @@ module Spree
       # Get the on_hand stock quantities
       # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
       def on_hand_by_stock_location_id
-        counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
+        quantities_by_location_id = counts_on_hand.to_a.group_by do |(_, stock_location_id), _|
           stock_location_id
         end.transform_values do |values|
           Spree::StockQuantities.new(
@@ -31,12 +31,13 @@ module Spree
             end.to_h
           )
         end
+        restore_location_order(quantities_by_location_id)
       end
 
-      # Get the on_hand stock quantities
+      # Get the backorderable stock quantities
       # @return [Hash<Integer=>Spree::StockQuantities>] A map of stock_location_ids to the stock quantities available in that location
       def backorderable_by_stock_location_id
-        backorderables.group_by(&:second).transform_values do |variant_ids|
+        quantities_by_location_id = backorderables.group_by(&:second).transform_values do |variant_ids|
           Spree::StockQuantities.new(
             variant_ids.map do |variant_id, _|
               variant = @variant_map[variant_id]
@@ -44,6 +45,7 @@ module Spree
             end.to_h
           )
         end
+        restore_location_order(quantities_by_location_id)
       end
 
       private
@@ -67,6 +69,12 @@ module Spree
           where(variant_id: @variants).
           where(stock_location_id: @stock_locations)
       end
+
+      def restore_location_order(quantities_by_location_id)
+        sorted_location_ids = @stock_locations.map(&:id)
+
+        quantities_by_location_id.sort_by { |key, _value| sorted_location_ids.index(key) }.to_h
+      end
     end
   end
 end

data/app/models/spree/stock/estimator.rb

@@ -39,7 +39,7 @@ module Spree
           cost = shipping_method.calculator.compute(package)
           if cost
             rate = shipping_method.shipping_rates.new(
-              cost: cost,
+              cost:,
               shipment: package.shipment
             )
             tax_calculator.calculate(rate).each do |tax|

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -25,7 +25,7 @@ module Spree
           Spree::InventoryUnit.new(
             pending: true,
             variant: line_item.variant,
-            line_item: line_item
+            line_item:
           )
         end
       end

data/app/models/spree/stock/package.rb

@@ -124,8 +124,8 @@ module Spree
         contents.each { |content_item| content_item.inventory_unit.state = content_item.state.to_s }
 
         Spree::Shipment.new(
-          order: order,
-          stock_location: stock_location,
+          order:,
+          stock_location:,
           inventory_units: contents.map(&:inventory_unit)
         )
       end

data/app/models/spree/stock/quantifier.rb

@@ -6,14 +6,18 @@ module Spree
       attr_reader :stock_items
 
       # @param [Variant] variant The variant to check inventory for.
-      # @param [StockLocation, Integer] stock_location The stock_location to check inventory in. If unspecified it will check inventory in all available StockLocations
-      def initialize(variant, stock_location = nil)
+      # @param [StockLocation, Integer] stock_location_or_id
+      #        The stock_location or stock location ID to check inventory in.
+      #        If unspecified it will check inventory in all available StockLocations
+      def initialize(variant, stock_location_or_id = nil)
         @variant = variant
-        @stock_items = Spree::StockItem.where(variant_id: variant)
-        if stock_location
-          @stock_items.where!(stock_location: stock_location)
-        else
-          @stock_items.joins!(:stock_location).merge!(Spree::StockLocation.active)
+        @stock_items = variant.stock_items.select do |stock_item|
+          if stock_location_or_id
+            stock_item.stock_location == stock_location_or_id ||
+              stock_item.stock_location_id == stock_location_or_id
+          else
+            stock_item.stock_location.active?
+          end
         end
       end
 
@@ -23,7 +27,7 @@ module Spree
       #   inventory is not tracked on the variant.
       def total_on_hand
         if @variant.should_track_inventory?
-          stock_items.sum(:count_on_hand)
+          stock_items.sum(&:count_on_hand)
         else
           Float::INFINITY
         end

data/app/models/spree/stock/simple_coordinator.rb

@@ -22,38 +22,65 @@ module Spree
     class SimpleCoordinator
       attr_reader :order
 
+      # @api private
+      attr_reader :inventory_units, :splitters, :stock_locations,
+        :filtered_stock_locations, :inventory_units_by_variant, :desired,
+        :availability, :allocator, :packages
+
       def initialize(order, inventory_units = nil)
         @order = order
-        @inventory_units = inventory_units || InventoryUnitBuilder.new(order).units
+        @inventory_units =
+          inventory_units || Spree::Config.stock.inventory_unit_builder_class.new(order).units
         @splitters = Spree::Config.environment.stock_splitters
 
-        filtered_stock_locations = Spree::Config.stock.location_filter_class.new(Spree::StockLocation.all, @order).filter
+        @filtered_stock_locations = Spree::Config.stock.location_filter_class.new(load_stock_locations, order).filter
         sorted_stock_locations = Spree::Config.stock.location_sorter_class.new(filtered_stock_locations).sort
         @stock_locations = sorted_stock_locations
 
         @inventory_units_by_variant = @inventory_units.group_by(&:variant)
-        @desired = Spree::StockQuantities.new(@inventory_units_by_variant.transform_values(&:count))
+        @desired = Spree::StockQuantities.new(inventory_units_by_variant.transform_values(&:count))
         @availability = Spree::Stock::Availability.new(
-          variants: @desired.variants,
-          stock_locations: @stock_locations
+          variants: desired.variants,
+          stock_locations:
         )
 
-        @allocator = Spree::Config.stock.allocator_class.new(@availability)
+        @allocator = Spree::Config.stock.allocator_class.new(availability)
       end
 
       def shipments
-        @shipments ||= build_shipments
+        @shipments ||= begin
+          @packages = build_packages
+          shipments = build_shipments
+
+          # Make sure we don't add the proposed shipments to the order
+          order.shipments = order.shipments - shipments
+
+          shipments
+        end
       end
 
       private
 
+      def load_stock_locations
+        Spree::StockLocation.all
+      end
+
       def build_shipments
+        # Turn the Stock::Packages into a Shipment with rates
+        packages.map do |package|
+          shipment = package.shipment = package.to_shipment
+          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
+          shipment
+        end
+      end
+
+      def build_packages
         # Allocate any available on hand inventory and remaining desired inventory from backorders
-        on_hand_packages, backordered_packages, leftover = @allocator.allocate_inventory(@desired)
+        on_hand_packages, backordered_packages, leftover = allocator.allocate_inventory(desired)
 
         raise Spree::Order::InsufficientStock.new(items: leftover.quantities) unless leftover.empty?
 
-        packages = @stock_locations.map do |stock_location|
+        packages = stock_locations.map do |stock_location|
           # Combine on_hand and backorders into a single package per-location
           on_hand = on_hand_packages[stock_location.id] || Spree::StockQuantities.new
           backordered = backordered_packages[stock_location.id] || Spree::StockQuantities.new
@@ -70,14 +97,7 @@ module Spree
         end.compact
 
         # Split the packages
-        packages = split_packages(packages)
-
-        # Turn the Stock::Packages into a Shipment with rates
-        packages.map do |package|
-          shipment = package.shipment = package.to_shipment
-          shipment.shipping_rates = Spree::Config.stock.estimator_class.new.shipping_rates(package)
-          shipment
-        end
+        split_packages(packages)
       end
 
       def split_packages(initial_packages)
@@ -87,20 +107,10 @@ module Spree
         end
       end
 
-      def sort_availability(availability)
-        sorted_availability = availability.sort_by do |stock_location_id, _|
-          @stock_locations.find_index do |stock_location|
-            stock_location.id == stock_location_id
-          end
-        end
-
-        Hash[sorted_availability]
-      end
-
       def get_units(quantities)
         # Change our raw quantities back into inventory units
         quantities.flat_map do |variant, quantity|
-          @inventory_units_by_variant[variant].shift(quantity)
+          inventory_units_by_variant[variant].shift(quantity)
         end
       end
     end

data/app/models/spree/stock/splitter/shipping_category.rb

@@ -24,7 +24,7 @@ module Spree
 
         def hash_to_packages(categories)
           packages = []
-          categories.each do |_id, contents|
+          categories.each_value do |contents|
             packages << build_package(contents)
           end
           packages

data/app/models/spree/stock_item.rb

@@ -20,7 +20,8 @@ module Spree
     after_save :conditional_variant_touch, if: :saved_changes?
     after_touch { variant.touch }
 
-    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
+    self.allowed_ransackable_attributes = ['count_on_hand', 'stock_location_id']
+    self.allowed_ransackable_associations = %w[variant]
 
     # @return [Array<Spree::InventoryUnit>] the backordered inventory units
     #   associated with this stock item

data/app/models/spree/stock_location.rb

@@ -26,12 +26,12 @@ module Spree
     validates_uniqueness_of :code, allow_blank: true, case_sensitive: false
 
     scope :active, -> { where(active: true) }
-    scope :order_default, -> { order(default: :desc, name: :asc) }
+    scope :order_default, -> { order(default: :desc, position: :asc) }
 
     after_create :create_stock_items, if: :propagate_all_variants?
     after_save :ensure_one_default
 
-    self.whitelisted_ransackable_attributes = %w[name]
+    self.allowed_ransackable_attributes = %w[name]
 
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
@@ -39,7 +39,7 @@ module Spree
 
     # Wrapper for creating a new stock item respecting the backorderable config
     def propagate_variant(variant)
-      stock_items.create!(variant: variant, backorderable: backorderable_default)
+      stock_items.create!(variant:, backorderable: backorderable_default)
     end
 
     # Return either an existing stock item or create a new one. Useful in
@@ -55,7 +55,7 @@ module Spree
     #
     # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
     def stock_item(variant_id)
-      stock_items.where(variant_id: variant_id).order(:id).first
+      stock_items.where(variant_id:).order(:id).first
     end
 
     # Attempts to look up StockItem for the variant, and creates one if not found.
@@ -101,8 +101,8 @@ module Spree
       if quantity < 1 && !stock_item(variant)
         raise InvalidMovementError.new(I18n.t('spree.negative_movement_absent_item'))
       end
-      stock_item_or_create(variant).stock_movements.create!(quantity: quantity,
-                                                            originator: originator)
+      stock_item_or_create(variant).stock_movements.create!(quantity:,
+                                                            originator:)
     end
 
     def fill_status(variant, quantity)
@@ -121,7 +121,7 @@ module Spree
 
     def ensure_one_default
       if default
-        Spree::StockLocation.where(default: true).where.not(id: id).each do |stock_location|
+        Spree::StockLocation.where(default: true).where.not(id:).find_each do |stock_location|
           stock_location.default = false
           stock_location.save!
         end

data/app/models/spree/stock_movement.rb

@@ -13,8 +13,8 @@ module Spree
 
     scope :recent, -> { order(created_at: :desc) }
 
-    self.whitelisted_ransackable_associations = %w[variant]
-    self.whitelisted_ransackable_attributes = ['quantity']
+    self.allowed_ransackable_associations = %w[variant]
+    self.allowed_ransackable_attributes = ['quantity']
 
     def readonly?
       !new_record?