spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/spree/price_list.rb

@@ -7,10 +7,12 @@ module Spree
 
     include Spree::SingleStoreResource
     include Spree::HasListPosition
+    include Spree::CanonicalDecimals
+
+    canonical_decimals :price_adjustment_percentage, places: 3
 
     MATCH_POLICIES = %w[all any].freeze
 
-    belongs_to :store, class_name: 'Spree::Store'
     # The owning agreement, or nil for a standalone list. An owned list is
     # reached only through its catalog — generic rule matching skips it in
     # SQL (see .for_context) — so a deactivated catalog's list goes dormant
@@ -95,6 +97,7 @@ module Spree
     # `catalog_id` is queryable so a picker can offer the lists that are
     # actually available — unowned, plus the one the catalog already holds.
     self.whitelisted_ransackable_attributes = %w[status match_policy starts_at ends_at catalog_id]
+    search_by :name
 
     scope :by_position, -> { ordered }
     scope :for_store, ->(store) { where(store: store) }
@@ -155,7 +158,7 @@ module Spree
     end
 
     def self.match_policies
-      MATCH_POLICIES.map { |key| [Spree.t(key), key] }
+      MATCH_POLICIES.map { |key| [I18n.t("spree.#{key}"), key] }
     end
 
     # Returns true if the price list is applicable to the context
@@ -334,9 +337,9 @@ module Spree
 
       return if prices_to_insert.empty?
 
-      # Use upsert_all with on_duplicate: :skip to handle race conditions
+      # Use upsert_all with on_duplicate: :skip to handle race conditions.
+      # Placeholders charge nothing, so the variants are not touched.
       Spree::Price.upsert_all(prices_to_insert, on_duplicate: :skip)
-      touch_variants(variant_ids)
       touch
     end
 
@@ -355,10 +358,13 @@ module Spree
       variant_ids = Spree::Variant.where(product_id: product_ids).distinct.pluck(:id)
       return if variant_ids.empty?
 
+      removed_prices = prices.where(variant_id: variant_ids)
+      priced_variant_ids = removed_prices.where.not(amount: nil).distinct.pluck(:variant_id)
+
       # Use delete_all for hard delete - this bypasses acts_as_paranoid
       # which is required for the unique index to work when re-adding products
-      prices.where(variant_id: variant_ids).delete_all
-      touch_variants(variant_ids)
+      removed_prices.delete_all
+      touch_variants(priced_variant_ids)
       touch
     end
 
@@ -387,9 +393,8 @@ module Spree
 
         current = current_values[price_id]
 
-        # Parse amounts using LocalizedNumber for proper decimal handling
-        amount = attrs[:amount].present? ? Spree::LocalizedNumber.parse(attrs[:amount]) : nil
-        compare_at_amount = attrs[:compare_at_amount].present? ? Spree::LocalizedNumber.parse(attrs[:compare_at_amount]) : nil
+        amount = Spree::Money::Rounding.parse_decimal(attrs[:amount])
+        compare_at_amount = Spree::Money::Rounding.parse_decimal(attrs[:compare_at_amount])
 
         # Clear compare_at_amount if it equals amount
         compare_at_amount = nil if compare_at_amount == amount

data/app/models/spree/price_rules/channel_rule.rb

@@ -9,11 +9,8 @@ module Spree
       # against raw `channel_id` rows directly. Scope confines the
       # existence check to the price-list's store so cross-store channel
       # IDs can't sneak in.
-      preference :channel_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Channel,
-                   scope: ->(rule) { rule.store.channels }
-                 )
+      preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                 scope: ->(rule) { rule.store.channels }
 
       def channels
         return [] if preferred_channel_ids.blank?
@@ -32,7 +29,7 @@ module Spree
       end
 
       def self.description
-        Spree.t('price_rules.channel_rule.description')
+        I18n.t('spree.price_rules.channel_rule.description')
       end
     end
   end

data/app/models/spree/price_rules/customer_group_rule.rb

@@ -10,11 +10,8 @@ module Spree
       # callers and decodes them on write so eligibility checks compare
       # against raw `customer_group_id` rows directly. Scope confines
       # the existence check to the price-list's store.
-      preference :customer_group_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::CustomerGroup,
-                   scope: ->(rule) { rule.store.customer_groups }
-                 )
+      preference :customer_group_ids, :array, of: :id, model: 'Spree::CustomerGroup', default: [],
+                 scope: ->(rule) { rule.store.customer_groups }
 
       def customer_groups
         return [] if preferred_customer_group_ids.blank?
@@ -33,7 +30,7 @@ module Spree
       end
 
       def self.description
-        Spree.t('price_rules.customer_group_rule.description')
+        I18n.t('spree.price_rules.customer_group_rule.description')
       end
 
       def self.superseded?

data/app/models/spree/price_rules/market_rule.rb

@@ -6,11 +6,8 @@ module Spree
       # against raw `market_id` rows directly. Scope confines the
       # existence check to the price-list's store so cross-store market
       # IDs can't sneak in.
-      preference :market_ids, :array, default: [],
-                 parse_on_set: normalize_id_preference(
-                   klass: Spree::Market,
-                   scope: ->(rule) { rule.store.markets }
-                 )
+      preference :market_ids, :array, of: :id, model: 'Spree::Market', default: [],
+                 scope: ->(rule) { rule.store.markets }
 
       def markets
         return [] if preferred_market_ids.blank?

data/app/models/spree/price_rules/user_rule.rb

@@ -10,9 +10,7 @@ module Spree
       # e.g. `usr_…`) from API callers and decodes them on write. Resolves
       # `Spree.customer_class` lazily — the user class is configured at boot,
       # and class-body evaluation runs before that on cold loads.
-      preference :user_ids, :array, default: [], parse_on_set: ->(values) {
-        normalize_id_preference(klass: Spree.customer_class).call(values)
-      }
+      preference :user_ids, :array, of: :id, model: -> { Spree.customer_class }, default: []
 
       def users
         return [] if preferred_user_ids.blank?

data/app/models/spree/product/channels.rb

@@ -43,8 +43,7 @@ module Spree
               "Spree::Product##{legacy_attr}= is deprecated; set #{publication_attr} on " \
               "ProductPublication instead (writes to every channel's publication). "
             )
-            super(value)
-            product_publications.each { |publication| publication.public_send("#{publication_attr}=", value) }
+            write_publication_date(legacy_attr, value)
           end
 
           # Reading +available_on+/+discontinue_on+ prefers the current-channel
@@ -92,6 +91,14 @@ module Spree
 
       private
 
+      # Writes a legacy date column together with the matching date on every
+      # channel's publication, so the two never disagree.
+      def write_publication_date(legacy_attr, value)
+        write_attribute(legacy_attr, value)
+        publication_attr = DEPRECATED_DATE_TO_PUBLICATION_FIELD.fetch(legacy_attr.to_sym)
+        product_publications.each { |publication| publication.public_send("#{publication_attr}=", value) }
+      end
+
       def assign_default_store
         self.store ||= Spree::Current.store || Spree::Store.default
       end

data/app/models/spree/product.rb

@@ -38,9 +38,9 @@ module Spree
     include Spree::StorePreferences
 
     publishes_lifecycle_events
+    publishes_events :activated, :approved, :archived, :back_in_stock, :drafted, :out_of_stock, :proposed, :rejected
 
-    MEMOIZED_METHODS = %w[total_on_hand category_and_ancestors
-                          default_variant_id tax_category default_variant variant_for_images
+    MEMOIZED_METHODS = %w[total_on_hand default_variant_id tax_category default_variant variant_for_images
                           primary_category buy_box_variants resolved_delivery_profile
                           purchasable? in_stock? backorderable? digital?]
 
@@ -242,8 +242,6 @@ module Spree
     after_create :set_default_variant
 
     after_save :auto_promote_default_variant
-    after_save :run_touch_callbacks, if: :saved_changes?
-    after_touch :touch_categories
 
     after_commit :auto_match_collections, if: :eligible_for_collection_matching?
 
@@ -302,9 +300,6 @@ module Spree
       where(id: (product_ids + custom_field_ids).uniq.compact)
     }
 
-    # Backward compatibility alias — remove in Spree 6.0
-    scope :multi_search, ->(*args) { search(*args) }
-
     scope :archivable, -> { where(status: %w[active draft]) }
     scope :by_source, ->(source) { send(source) }
     scope :published, -> { where(status: 'active') }
@@ -366,7 +361,21 @@ module Spree
       super(manual_ids | collections.automatic.ids)
     end
 
-    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at seller_id]
+    self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on status available_on created_at updated_at seller_id price]
+
+    # The default variant's base price in the current currency — what the
+    # product lists show — so a list can filter on it like a column.
+    ransacker :price, type: :decimal do |parent|
+      prices = Spree::Price.arel_table
+      Arel::Nodes::Grouping.new(
+        prices.project(prices[:amount]).
+          where(prices[:variant_id].eq(parent.table[:default_variant_id])).
+          where(prices[:currency].eq(Spree::Current.currency)).
+          where(prices[:price_list_id].eq(nil)).
+          where(prices[:deleted_at].eq(nil)).
+          take(1)
+      )
+    end
     self.whitelisted_ransackable_associations = %w[categories collections store channels variants default_variant tags labels
                                                    product_type product_categories option_types seller]
     # The storefront filters by tag, category and collection; every other hop
@@ -375,9 +384,15 @@ module Spree
     self.storefront_ransackable_associations = %w[tags categories collections]
     self.whitelisted_ransackable_scopes = %w[not_discontinued search_by_name in_taxon in_category in_categories in_collection price_between
                                              price_lte price_gte
-                                             search multi_search in_stock out_of_stock with_option_value_ids
+                                             search in_stock out_of_stock with_option_value_ids
 
                                              ascend_by_price descend_by_price]
+    self.ransackable_scope_types = {
+      'in_taxon' => 'id', 'in_category' => 'id', 'in_collection' => 'id',
+      'in_categories' => { list: 'id' }, 'with_option_value_ids' => { list: 'id' },
+      'price_between' => %w[decimal decimal], 'price_lte' => 'decimal', 'price_gte' => 'decimal',
+      'ascend_by_price' => 'boolean', 'descend_by_price' => 'boolean'
+    }
 
     # All product-level convenience attributes delegate to the default variant —
     # one target, no branching. Reads resolve the existing default variant
@@ -693,12 +708,12 @@ module Spree
     # variant), reading preloaded associations to avoid an N+1.
     # @return [ActiveSupport::TimeWithZone, nil]
     def preorder_ships_at
-      candidates = has_variants? ? variants : [master]
+      candidates = has_variants? ? variants : [default_variant]
       candidates.select(&:preorder?).filter_map(&:preorder_ships_at).max
     end
 
     def discontinue!
-      self.discontinue_on = Time.current
+      write_publication_date(:discontinue_on, Time.current)
       self.status = 'archived'
       save(validate: false)
     end
@@ -817,7 +832,13 @@ module Spree
       Spree::Products::AutoMatchCollectionsJob.set(wait: 30.seconds).perform_later(id)
     end
 
-    def to_csv(store = nil)
+    # @param seller [Spree::Seller, nil] the seller exporting their own
+    #   products, whose rows cover only their own locations; nil for the
+    #   operator, whose rows cover the marketplace's and the product's seller's
+    # @param default_stock_location [Spree::StockLocation, nil] the location
+    #   the full rows carry; further locations get stock-only rows. The
+    #   store's default when nil
+    def to_csv(store = nil, seller: nil, default_stock_location: nil)
       store ||= self.store
       properties_for_csv = if respond_to?(:product_properties) && Spree::Config.respond_to?(:product_properties_enabled) && Spree::Config[:product_properties_enabled]
                              Spree::Property.order(:position).flat_map do |property|
@@ -840,11 +861,12 @@ module Spree
       all_variants = variants.to_a
       default_currency = store.default_currency
       additional_currencies = store.supported_currencies_list.map(&:iso_code) - [default_currency]
+      default_stock_location ||= store.default_stock_location
 
       # Primary rows in the store's default currency
       all_variants.each_with_index do |variant, index|
         csv_lines << Spree::CSV::ProductVariantPresenter.new(self, variant, index, properties_for_csv, categories_for_csv, store,
-                                                             custom_field_values).call
+                                                             custom_field_values, default_stock_location: default_stock_location).call
       end
 
       # Price-only rows for each additional currency
@@ -857,6 +879,25 @@ module Spree
         end
       end
 
+      # Stock-only rows for every other location the importer can name back. A
+      # row the import cannot route to its variant is left out: with no SKU it
+      # would land on the default variant.
+      location_owner_ids = seller ? [seller.id] : [nil, seller_id].uniq
+      all_variants.each do |variant|
+        next unless variant.should_track_inventory?
+        next if variant.sku.blank? && variant != default_variant
+
+        variant.stock_levels.each do |stock_level|
+          location = stock_level.stock_location
+          next if location.nil? || location == default_stock_location
+          next unless location.store_id == store.id && location_owner_ids.include?(location.seller_id)
+          next if stock_level.count_on_hand.zero?
+
+          csv_lines << Spree::CSV::ProductVariantPresenter.new(self, variant, 0, [], [], store,
+                                                               stock_level: stock_level).call
+        end
+      end
+
       csv_lines
     end
 
@@ -972,23 +1013,6 @@ module Spree
       errors.add(:seller, :invalid)
     end
 
-    def run_touch_callbacks
-      run_callbacks(:touch)
-    end
-
-    def category_and_ancestors
-      @category_and_ancestors ||= categories.map(&:self_and_ancestors).flatten.uniq
-    end
-
-    # Iterate through this product's categories and touch their timestamps in a batch
-    def touch_categories
-      if categories.any?
-        Spree::Products::TouchCategoriesJob.
-          set(wait: 5.seconds).
-          perform_later(category_and_ancestors.map(&:id))
-      end
-    end
-
     def ensure_not_in_complete_orders
       if orders.complete.any?
         errors.add(:base, :cannot_destroy_if_attached_to_line_items)

data/app/models/spree/product_submission.rb

@@ -56,17 +56,5 @@ module Spree
     def store
       product&.store
     end
-
-    # Named explicitly rather than left to the `Spree::Api::V3::` convention:
-    # a serializer at that level is picked up by the Store API's generated
-    # types and OpenAPI document, and a review decision is not something the
-    # storefront has any business describing. The seller's own view is the
-    # right shape for an event — it already withholds who decided, which a
-    # webhook payload leaving the marketplace should not carry.
-    #
-    # @return [Class]
-    def event_serializer_class
-      Spree::Api::V3::Seller::ProductSubmissionSerializer
-    end
   end
 end

data/app/models/spree/product_type.rb

@@ -10,7 +10,6 @@ module Spree
     TRANSLATABLE_FIELDS = %i[name].freeze
     translates(*TRANSLATABLE_FIELDS, column_fallback: Spree.mobility_column_fallback)
 
-    belongs_to :store, class_name: 'Spree::Store'
     # Creation-time template only: stamped onto the product when it is
     # created with this type, never managed through it afterwards — the same
     # doctrine as every other type-driven attribute. Nil means the store's
@@ -38,6 +37,7 @@ module Spree
     validates :store, presence: true
 
     self.whitelisted_ransackable_attributes = %w[name]
+    search_by :name
     self.whitelisted_ransackable_associations = %w[option_types]
 
     # Replace-set writer for the flat API payload. Each entry is

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -42,7 +42,7 @@ module Spree
         # @param line_item [Spree::LineItem]
         # @return [BigDecimal] never positive
         def compute_amount(line_item)
-          line_item.price * gifted_quantity_of(line_item) * -1
+          -Spree::Money::Rounding.to_currency(line_item.price * gifted_quantity_of(line_item), line_item.currency)
         end
 
         # Tops the order up to the promised quantity and discounts it.
@@ -104,6 +104,31 @@ module Spree
           quantifier.can_supply? quantity
         end
 
+        # Whether the promotion gives its gift on this order, judged with other
+        # promotions' gifts still counting toward its own rules — a single
+        # level, so two gift promotions measuring each other cannot loop.
+        #
+        # @param order [Spree::Order, Spree::Cart]
+        # @return [Boolean]
+        def gives_away?(order)
+          promotion.eligible?(order, own_gift_only: true) && qualifies_beyond_the_gift?(order, own_gift_only: true)
+        end
+
+        # How many units of this line the promotion pays for — never more than
+        # the line holds, so a shopper buying three of a variant gifted once
+        # still pays for two. `quantity` is nullable and written by `upsert_all`,
+        # which skips validation, so a missing or negative one gifts nothing
+        # rather than raising or turning the discount into a surcharge.
+        #
+        # @param line_item [Spree::LineItem]
+        # @return [Integer]
+        def gifted_quantity_of(line_item)
+          gifted = promotion_action_line_items.detect { |item| item.variant_id == line_item.variant_id }
+          return 0 if gifted.nil?
+
+          [[line_item.quantity, gifted.quantity.to_i].min, 0].max
+        end
+
         private
 
         # Whether this line holds a variant the promotion gives away.
@@ -117,30 +142,15 @@ module Spree
         # to hold a line the rules count with units this action is not already
         # covering. A promotion with no rules qualifies on anything, so there is
         # nothing for the gift to stand in for.
-        def qualifies_beyond_the_gift?(order)
+        def qualifies_beyond_the_gift?(order, options = {})
           return true if promotion.promotion_rules.empty?
 
           order.line_items.any? do |line_item|
-            promotion.line_item_actionable?(order, line_item) &&
+            promotion.line_item_actionable?(order, line_item, options) &&
               gifted_quantity_of(line_item) < line_item.quantity
           end
         end
 
-        # How many units of this line the promotion pays for — never more than
-        # the line holds, so a shopper buying three of a variant gifted once
-        # still pays for two. `quantity` is nullable and written by `upsert_all`,
-        # which skips validation, so a missing or negative one gifts nothing
-        # rather than raising or turning the discount into a surcharge.
-        #
-        # @param line_item [Spree::LineItem]
-        # @return [Integer]
-        def gifted_quantity_of(line_item)
-          gifted = promotion_action_line_items.detect { |item| item.variant_id == line_item.variant_id }
-          return 0 if gifted.nil?
-
-          [[line_item.quantity, gifted.quantity.to_i].min, 0].max
-        end
-
         def add_missing_line_items(order)
           added_results = promotion_action_line_items.map do |item|
             missing = item.quantity.to_i - order.quantity_of(item.variant)

data/app/models/spree/promotion/rules/category.rb

@@ -35,7 +35,7 @@ module Spree
         # Preferences
         #
         MATCH_POLICIES = %w(any all)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
 
         #
         # Attributes
@@ -47,10 +47,6 @@ module Spree
         #
         after_save :add_categories
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible_category_ids
           @eligible_category_ids ||= promotion_rule_categories.pluck(:category_id)
         end

data/app/models/spree/promotion/rules/channel.rb

@@ -8,15 +8,8 @@ module Spree
         # against the order's raw `channel_id` directly. Scope confines the
         # existence check to the promotion's store so cross-store channel
         # IDs can't sneak in.
-        preference :channel_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::Channel,
-                     scope: ->(rule) { rule.promotion.store.channels }
-                   )
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
+        preference :channel_ids, :array, of: :id, model: 'Spree::Channel', default: [],
+                   scope: ->(rule) { rule.promotion.store.channels }
 
         def channels
           return Spree::Channel.none if preferred_channel_ids.blank?

data/app/models/spree/promotion/rules/country.rb

@@ -9,15 +9,10 @@ module Spree
   class Promotion
     module Rules
       class Country < Spree::PromotionRule
-        preference :country_codes, :array, default: [], parse_on_set: lambda { |values|
-          normalize_id_preference.call(values).map(&:upcase)
-        }
+        preference :country_codes, :array, of: :string, format: :iso_country, default: [],
+                   parse_on_set: ->(values) { Array(values).flat_map { |value| value.to_s.split(',') }.map { |code| code.strip.upcase }.compact_blank }
         preference :country_id, :integer # legacy single-country shortcut
-        preference :country_code, :string # legacy ISO-based shortcut
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
+        preference :country_code, :string, format: :iso_country # legacy ISO-based shortcut
 
         def countries
           isos = configured_country_codes.presence || [configured_country_code].compact_blank

data/app/models/spree/promotion/rules/currency.rb

@@ -3,11 +3,7 @@ module Spree
   class Promotion
     module Rules
       class Currency < Spree::PromotionRule
-        preference :currency, :string
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
+        preference :currency, :string, format: :currency
 
         def eligible?(order, options = {})
           return true if order.currency == preferred_currency

data/app/models/spree/promotion/rules/customer_group.rb

@@ -9,15 +9,8 @@ module Spree
         # Scoped to the promotion's own store: groups are store-owned, so an
         # id from elsewhere must raise rather than link a promotion to an
         # audience its store cannot see.
-        preference :customer_group_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::CustomerGroup,
-                     scope: ->(rule) { rule.promotion.store.customer_groups }
-                   )
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
+        preference :customer_group_ids, :array, of: :id, model: 'Spree::CustomerGroup', default: [],
+                   scope: ->(rule) { rule.promotion.store.customer_groups }
 
         def customer_groups
           return Spree::CustomerGroup.none if preferred_customer_group_ids.blank?

data/app/models/spree/promotion/rules/first_order.rb

@@ -4,10 +4,6 @@ module Spree
       class FirstOrder < Spree::PromotionRule
         attr_reader :user, :email, :store
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, options = {})
           @user = order.try(:customer) || options[:user]
           @email = if options[:email].present?

data/app/models/spree/promotion/rules/item_total.rb

@@ -1,23 +1,19 @@
 # A rule to apply to an order greater than (or greater than or equal to)
-# a specific amount
+# a specific amount. Free gifts do not count toward it.
 module Spree
   class Promotion
     module Rules
       class ItemTotal < Spree::PromotionRule
-        preference :amount_min, :decimal, default: 100.00
+        preference :amount_min, :money, default: 100.00
         preference :operator_min, :string, default: '>'
-        preference :amount_max, :decimal, default: nil, nullable: true
+        preference :amount_max, :money, default: nil, nullable: true
         preference :operator_max, :string, default: '<'
 
         OPERATORS_MIN = ['gt', 'gte']
         OPERATORS_MAX = ['lt', 'lte']
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
-        def eligible?(order, _options = {})
-          item_total = order.item_total
+        def eligible?(order, options = {})
+          item_total = order.item_total - order.gift_amount(promotion: promotion, own_gift_only: options.fetch(:own_gift_only, false))
 
           lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal(preferred_amount_min.to_s))
 
@@ -43,7 +39,7 @@ module Spree
           if preferred_amount_max.present?
             Spree::Money.new(preferred_amount_max, currency: order.currency).to_s
           else
-            Spree.t('no_maximum')
+            I18n.t('spree.no_maximum')
           end
         end
 

data/app/models/spree/promotion/rules/market.rb

@@ -8,15 +8,8 @@ module Spree
         # against the order's raw `market_id` directly. Scope confines the
         # existence check to the promotion's store so cross-store market
         # IDs can't sneak in.
-        preference :market_ids, :array, default: [],
-                   parse_on_set: normalize_id_preference(
-                     klass: Spree::Market,
-                     scope: ->(rule) { rule.promotion.store.markets }
-                   )
-
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
+        preference :market_ids, :array, of: :id, model: 'Spree::Market', default: [],
+                   scope: ->(rule) { rule.promotion.store.markets }
 
         def markets
           return Spree::Market.none if preferred_market_ids.blank?

data/app/models/spree/promotion/rules/one_use_per_user.rb

@@ -2,10 +2,6 @@ module Spree
   class Promotion
     module Rules
       class OneUsePerUser < Spree::PromotionRule
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, _options = {})
           if order.customer.present?
             if promotion.used_by?(order.customer, [order])

data/app/models/spree/promotion/rules/option_value.rb

@@ -3,19 +3,15 @@ module Spree
     module Rules
       class OptionValue < Spree::PromotionRule
         MATCH_POLICIES = %w(any)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
         # Stored as raw Spree::OptionValue ids. Accepts prefixed IDs (`optval_…`)
         # from API callers and decodes them on write so eligibility checks compare
         # against stable option-value rows, not join-table ids that shift when
         # variants are reconfigured.
-        preference :eligible_values, :array, default: [],
-                   parse_on_set: normalize_id_preference(klass: Spree::OptionValue)
+        preference :eligible_values, :array, of: :id, model: 'Spree::OptionValue', default: []
 
         # @param promotable [Object]
         # @return [Boolean]
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
 
         # @return [ActiveRecord::Relation<Spree::OptionValue>]
         def option_values

data/app/models/spree/promotion/rules/product.rb

@@ -28,7 +28,7 @@ module Spree
         # Preferences
         #
         MATCH_POLICIES = %w(any all none)
-        preference :match_policy, :string, default: MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first, choices: MATCH_POLICIES
 
         #
         # Attributes
@@ -49,10 +49,6 @@ module Spree
           @eligible_product_ids ||= product_promotion_rules.pluck(:product_id)
         end
 
-        def applicable?(promotable)
-          promotable.is_a?(Spree::Order) || promotable.is_a?(Spree::Cart)
-        end
-
         def eligible?(order, _options = {})
           return true if eligible_product_ids.empty?