spree_core 6.0.0.rc1 → 6.0.0.rc2

data/lib/spree/core/preferences/preferable.rb

@@ -18,9 +18,16 @@ require 'spree/core/preferences/preferable_class_methods'
 module Spree::Preferences::Preferable
   extend ActiveSupport::Concern
 
+  BOOLEAN_TYPE = ActiveModel::Type::Boolean.new
+  INTEGER_TYPE = ActiveModel::Type::Integer.new
+  STRING_TYPE = ActiveModel::Type::String.new
+
   included do
     serialize :preferences, coder: Spree::Metadata::HashSerializer
     extend Spree::Preferences::PreferableClassMethods
+
+    # The preferences read and written under their plain names (see `exposes_preferences`).
+    class_attribute :exposed_preference_names, instance_accessor: false, default: Set.new.freeze
   end
 
   # JSON keeps decimals and times as strings; the declared type turns them
@@ -34,7 +41,7 @@ module Spree::Preferences::Preferable
     return value unless value.is_a?(String)
 
     case type
-    when :decimal then BigDecimal(value, exception: false) || value
+    when :decimal, :money then BigDecimal(value, exception: false) || value
     when :datetime then Time.zone.iso8601(value)
     else value
     end
@@ -42,6 +49,17 @@ module Spree::Preferences::Preferable
     value
   end
 
+  # The record class an `of: :id` preference points at. Declared as a class
+  # name or a block, so a declaration never loads another model, nor fixes a
+  # configurable class like `Spree.customer_class`, at class load.
+  #
+  # @param definition [Hash] a preference definition
+  # @return [Class]
+  def self.preference_model(definition)
+    model = definition[:model]
+    model.respond_to?(:call) ? model.call : model.to_s.constantize
+  end
+
   def get_preference(name)
     has_preference! name
     public_send(:"preferred_#{name}")
@@ -81,6 +99,24 @@ module Spree::Preferences::Preferable
     choices.respond_to?(:call) ? choices.call : choices
   end
 
+  # The currency a `:money` preference is in: its declared `currency:` source
+  # (another preference, or a method of the record), else the record's own
+  # `currency` preference. Values about to be assigned win over stored ones,
+  # so a request changing both the amount and its currency is read as one.
+  #
+  # @param name [Symbol, String]
+  # @param pending [Hash{String => Object}] values not yet assigned
+  # @return [String, nil] nil for an amount in any currency
+  def money_preference_currency(name, pending = {})
+    declared = preference_definition(name)[:currency]
+    source = declared || :currency
+    # A currency sent in the same payload wins, even a blank one clearing it.
+    return pending[source.to_s].presence if pending.key?(source.to_s)
+    return get_preference(source).presence if has_preference?(source)
+
+    public_send(source).presence if declared && respond_to?(source)
+  end
+
   def has_preference!(name)
     raise NoMethodError, "#{name} preference not defined" unless has_preference? name
   end
@@ -142,6 +178,53 @@ module Spree::Preferences::Preferable
     clear_attribute_change(:preferences) if persisted? && !already_changed
   end
 
+  # Writes a `preferences` payload an API client sent. The whole payload is
+  # checked against the type's schema first, so nothing is written when any
+  # value is wrong. Then each value goes through its typed writer. A secret
+  # sent back masked, as it was read, keeps the stored one; `null` clears it.
+  #
+  # @param values [Hash, ActionController::Parameters]
+  # @param pointer [String] where the preferences object sits in the request,
+  #   e.g. `/rules/1/preferences`, so a failure names its place
+  # @raise [Spree::Preferences::InvalidPreferences] naming every value that does not match
+  # @return [void]
+  def assign_preferences(values, pointer: '/preferences')
+    values = values.respond_to?(:to_unsafe_h) ? values.to_unsafe_h : values.to_h
+    values = values.deep_stringify_keys
+    failures = self.class.preference_failures(values)
+    failures += money_precision_failures(values) if failures.empty?
+    raise Spree::Preferences::InvalidPreferences.new(failures, prefix: pointer) if failures.any?
+
+    values.each do |key, value|
+      next if secret_preference?(key) && Spree::Preferences::Masking.masked?(value)
+
+      begin
+        set_preference(key, value)
+      rescue ActiveRecord::RecordNotFound => e
+        raise Spree::Preferences::InvalidPreferences.new([{ pointer: "/#{key}", message: e.message }], prefix: pointer)
+      end
+    end
+  end
+
+  # A stored value in the form the schema describes. Rows written before the
+  # declarations were typed can hold a number where an exact decimal string
+  # is declared (an `amounts` hash, a decimal default from YAML), or a string
+  # where a number or boolean is; read back as they are, a client sending
+  # them unchanged would be refused.
+  #
+  # @param value [Object] the stored value
+  # @param definition [Hash] its preference definition
+  # @return [Object]
+  def wire_preference_value(value, definition)
+    return BigDecimal(value.to_s).as_json if %i[decimal money].include?(definition[:type]) && value.is_a?(Numeric)
+    return nil if value == '' && definition[:nullable] && %i[integer boolean].include?(definition[:type])
+    return cast_preference_item(value, :integer) if definition[:type] == :integer && value.is_a?(String)
+    return convert_preference_value(value, :boolean, nullable: definition[:nullable]) if definition[:type] == :boolean && value.is_a?(String)
+    return value if value.nil? || (definition[:type] == :array && !value.is_a?(Array))
+
+    cast_preference_contents(value, definition)
+  end
+
   # Names of the preferences the last save changed, secrets included.
   #
   # @return [Array<Symbol>]
@@ -151,6 +234,24 @@ module Spree::Preferences::Preferable
 
   private
 
+  # A `:money` value with more decimals than its currency has is refused, as
+  # every other amount on the API is. The schema has already checked the
+  # format; it cannot know the currency.
+  def money_precision_failures(values)
+    values.filter_map do |key, value|
+      next unless value.is_a?(String) && has_preference?(key) && preference_type(key) == :money
+
+      currency = money_preference_currency(key, values)
+      amount = BigDecimal(value, exception: false)
+      next if currency.blank? || amount.nil?
+
+      places = Spree::Money::Rounding.precision(currency)
+      next if amount.round(places) == amount
+
+      { pointer: "/#{key}", message: I18n.t('spree.errors.messages.money_preference_too_many_decimals', count: places, currency: currency) }
+    end
+  end
+
   def preference_definition(name)
     has_preference! name
     self.class.preference_definitions[name.to_sym]
@@ -162,7 +263,7 @@ module Spree::Preferences::Preferable
   def stored_default(name)
     default = preference_default(name)
     type = preference_type(name)
-    return default if default.nil? || %i[decimal datetime].exclude?(type)
+    return default if default.nil? || %i[decimal money datetime].exclude?(type)
 
     convert_preference_value(default, type, nullable: true).as_json
   end
@@ -182,16 +283,95 @@ module Spree::Preferences::Preferable
       # `(value, owner = nil)` shapes.
       value = parse_on_set.arity.abs > 1 ? parse_on_set.call(value, self) : parse_on_set.call(value)
     end
+    # Spree 6.0 bridge, removed with incomplete declarations in 6.1: an id list
+    # an extension declared without `of: :id` still has its prefixed ids
+    # decoded, as the API did for every `*_ids` key before.
+    if definition[:type] == :array && definition[:of].nil? && name.to_s.end_with?('_ids') && value.is_a?(Array)
+      value = value.map { |id| (Spree::PrefixedId.decode_prefixed_id(id) if Spree::PrefixedId.prefixed_id?(id)) || id }
+    end
     value = convert_preference_value(value, definition[:type], nullable: definition[:nullable])
+    value = cast_preference_contents(value, definition)
     # Decimals and times are kept in the string form JSON stores, so a record
     # read back from the database and one just written compare equal and
     # setting the same value is not a change. The reader restores them.
-    value = value.as_json if %i[decimal datetime].include?(definition[:type])
+    value = value.as_json if %i[decimal money datetime].include?(definition[:type])
 
     Spree::Deprecation.warn("`#{name}` is deprecated. #{definition[:deprecated]}") if definition[:deprecated]
     value
   end
 
+  # Casts what a typed `:array` or `:hash` holds to its declared item type, in
+  # the form JSON stores. A value that does not cast is left as it came, so
+  # validation can name it rather than a silent zero hiding it.
+  def cast_preference_contents(value, definition)
+    case definition[:type]
+    when :array
+      case definition[:of]
+      when nil then value
+      when :id then decode_preference_ids(value, definition)
+      when :object then value.map { |item| cast_preference_object(item, definition[:properties]) }
+      else split_preference_list(value).map { |item| cast_preference_item(item, definition[:of]) }
+      end
+    when :hash
+      return value unless definition[:values] && value.is_a?(Hash)
+
+      value.to_h do |key, item|
+        key = definition[:keys] == :currency ? key.to_s.upcase : key.to_s
+        [key, cast_preference_item(item, definition[:values])]
+      end
+    else
+      value
+    end
+  end
+
+  # A comma-separated string is a list too: what a plain text field sends.
+  def split_preference_list(values)
+    values.flat_map { |item| item.is_a?(String) ? item.split(',') : [item] }
+          .map { |item| item.is_a?(String) ? item.strip : item }
+          .reject { |item| item.respond_to?(:empty?) && item.empty? }
+  end
+
+  def cast_preference_item(value, item_type)
+    case item_type
+    when :string then value.to_s
+    when :integer then Integer(value.to_s, 10, exception: false) || value
+    when :decimal, :money then BigDecimal(value.to_s, exception: false)&.as_json || value
+    when :boolean then BOOLEAN_TYPE.cast(value)
+    else value
+    end
+  end
+
+  def cast_preference_object(item, properties)
+    return item unless item.respond_to?(:to_h) && !item.is_a?(Array)
+
+    item.to_h.stringify_keys.slice(*properties.keys.map(&:to_s)).to_h do |key, value|
+      [key, cast_preference_item(value, properties[key.to_sym])]
+    end
+  end
+
+  # Turns a list of record ids into the raw primary keys the preference
+  # stores. A prefixed id must carry the declared model's prefix — a
+  # channel's id never decodes into a market id — and every id must belong to
+  # the record's scope, so a rule cannot point at another store's records.
+  #
+  # @raise [ActiveRecord::RecordNotFound] naming the ids that were not found
+  def decode_preference_ids(values, definition)
+    model = Spree::Preferences::Preferable.preference_model(definition)
+    ids = split_preference_list(values).map(&:to_s).map do |id|
+      Spree::PrefixedId.prefixed_id?(id) ? (model.decode_prefixed_id(id)&.to_s || id) : id
+    end
+    return ids if ids.empty?
+
+    relation = definition[:scope] ? definition[:scope].call(self) : model
+    found = relation.where(id: ids.reject { |id| Spree::PrefixedId.prefixed_id?(id) }).pluck(:id).map(&:to_s).to_set
+    missing = ids.reject { |id| found.include?(id) }
+    if missing.any?
+      raise ActiveRecord::RecordNotFound.new("Couldn't find #{model.name} with id=#{missing.join(',')}", model.name)
+    end
+
+    ids
+  end
+
   # Assigns a new hash rather than calling the store accessor's writer, which
   # skips writing nil to a missing key — leaving the default in force when nil
   # was meant. Rails still sees no change when the value is the one stored.
@@ -206,40 +386,46 @@ module Spree::Preferences::Preferable
     end
   end
 
+  # Whitespace alone is no number or boolean, so for those it is blank too; a
+  # string keeps it.
+  def blank_preference_value?(value, type = nil)
+    return true if value.nil? || (value.respond_to?(:empty?) && value.empty?)
+
+    %i[integer boolean].include?(type) && value.is_a?(String) && value.strip.empty?
+  end
+
   def convert_preference_value(value, type, nullable: false)
     case type
+    # Strings, integers and booleans cast the way Rails casts attributes (and
+    # `has_json` its keys). Our own rule on top: a blank value stays nil for a
+    # nullable preference, so it can fall back to another, and becomes the
+    # type's empty value otherwise.
     when :string, :text
-      # A nullable string keeps "unset" (nil / empty string) as nil so it can
-      # fall back to another value, instead of collapsing it to "".
-      if nullable && (value.nil? || (value.respond_to?(:empty?) && value.empty?))
-        nil
+      if blank_preference_value?(value)
+        nullable ? nil : ''
       else
-        value.to_s
+        STRING_TYPE.cast(value)
       end
     when :password
       value.to_s
-    when :decimal
-      decimal_value = value.presence
+    when :decimal, :money
+      # A number or canonical decimal text only: "1,599.99" raises rather
+      # than being read as 1.
+      decimal_value = value.is_a?(String) ? value.presence : value
       decimal_value ||= 0 unless nullable
-      decimal_value.present? ? decimal_value.to_s.to_d : decimal_value
+      decimal_value.nil? ? nil : Spree::Money::Rounding.parse_decimal(decimal_value)
     when :integer
-      int_value = value.presence
-      int_value ||= 0 unless nullable
-      int_value.present? ? int_value.to_i : int_value
+      if blank_preference_value?(value, :integer)
+        nullable ? nil : 0
+      else
+        INTEGER_TYPE.cast(value) || 0
+      end
     when :boolean
-      # A nullable boolean keeps "unset" (nil / empty string) as nil so it can
-      # fall back to another value, instead of collapsing it to false. An
-      # explicit false is preserved (it is neither nil nor empty).
-      if nullable && (value.nil? || (value.respond_to?(:empty?) && value.empty?))
-        nil
-      elsif value.is_a?(FalseClass) ||
-          value.nil? ||
-          value == 0 ||
-          value&.to_s =~ /^(f|false|0)$/i ||
-          (value.respond_to?(:empty?) && value.empty?)
-        false
+      # An explicit false is kept: it is neither nil nor empty.
+      if blank_preference_value?(value, :boolean)
+        nullable ? nil : false
       else
-        true
+        BOOLEAN_TYPE.cast(value)
       end
     when :array
       value.is_a?(Array) ? value : Array.wrap(value)

data/lib/spree/core/preferences/preferable_class_methods.rb

@@ -37,12 +37,42 @@ module Spree::Preferences
       preference_declarations_cache[:secrets] ||= declared_preference_types.filter_map { |name, type| name if type == :password }.freeze
     end
 
+    # The value types a list item, a hash value or an object property may
+    # declare — what {Spree::PreferenceSchema::JsonSchema} compiles to JSON
+    # Schema, along with its `FORMATS`.
+    ITEM_TYPES = %i[string integer decimal money boolean id object].freeze
+
     # Declares a typed preference with a `preferred_<name>` reader and writer
     # and a `prefers_<name>?` query. On a model, the value lives in the
     # `preferences` column (`secret_preferences` for a `:password` one) as a
     # Rails store accessor, which brings the change methods with it:
     # `preferred_<name>_changed?`, `_change`, `_was`,
     # `saved_change_to_preferred_<name>?` and `preferred_<name>_before_last_save`.
+    #
+    # The declaration is the preference's contract on the wire, so it states
+    # the full type:
+    #
+    #   preference :amount_min,    :money
+    #   preference :channel_ids,   :array, of: :id, model: 'Spree::Channel', scope: ->(rule) { rule.store.channels }
+    #   preference :country_codes, :array, of: :string, format: :iso_country
+    #   preference :match_policy,  :string, choices: %w[any all none]
+    #   preference :amounts,       :hash, keys: :currency, values: :money
+    #   preference :tiers,         :array, of: :object, properties: { threshold: :money, value: :decimal }
+    #
+    # @param name [Symbol]
+    # @param type [Symbol] `:string`, `:text`, `:boolean`, `:integer`, `:decimal`, `:money`,
+    #   `:array`, `:hash`, `:password`, `:date` or `:datetime`
+    # @option options [Symbol] :of the type of each item of an `:array`
+    # @option options [Symbol] :keys the type of a `:hash`'s keys (`:string` or `:currency`)
+    # @option options [Symbol] :values the type of a `:hash`'s values
+    # @option options [Hash{Symbol => Symbol}] :properties the fields of each `of: :object` item
+    # @option options [Symbol] :format a string's domain format (see {Spree::PreferenceSchema::JsonSchema::FORMATS})
+    # @option options [String, Proc] :model the record class an `of: :id` list points at
+    # @option options [Proc] :scope `->(owner) { relation }` the ids must be found in
+    # @option options [Array, Proc] :choices the fixed set a value must come from
+    # @option options [Symbol] :currency where a `:money` preference's currency comes
+    #   from: another preference or a method of the record. Defaults to the
+    #   record's `currency` preference; with neither, the amount is in any currency.
     def preference(name, type, *args)
       name = name.to_sym
       secret = type == :password
@@ -52,20 +82,39 @@ module Spree::Preferences
       end
 
       options = args.extract_options!
-      options.assert_valid_keys(:default, :deprecated, :in, :internal, :nullable, :parse_on_set)
+      options.assert_valid_keys(:default, :deprecated, :in, :choices, :internal, :nullable, :parse_on_set,
+                                :of, :keys, :values, :properties, :format, :model, :scope, :currency)
+      if options.key?(:in)
+        Spree::Deprecation.warn("`preference :#{name}, in:` is deprecated. Use `choices:` instead.")
+        options[:choices] ||= options.delete(:in)
+      end
+      check_preference_declaration(name, type, options)
+
       default = options[:default]
-      default = -> { options[:default] } unless default.is_a?(Proc)
+      dynamic_default = default.is_a?(Proc)
+      default = -> { options[:default] } unless dynamic_default
       own_preference_definitions[name] = {
         type: type,
         default: default,
+        # Computed when read (the default store's currency, say), so it
+        # differs between stores and is not part of the preference's schema.
+        dynamic_default: dynamic_default,
         deprecated: options[:deprecated],
         # Whether the system writes the value rather than the operator — a
         # value a provider hands back, kept out of every admin form.
         internal: options[:internal],
         # The fixed set a value must come from; turns a text box into a picker.
-        choices: options[:in],
+        choices: options[:choices],
         nullable: options[:nullable],
-        parse_on_set: options[:parse_on_set]
+        parse_on_set: options[:parse_on_set],
+        of: options[:of],
+        keys: options[:keys],
+        values: options[:values],
+        properties: options[:properties],
+        format: options[:format],
+        model: options[:model],
+        scope: options[:scope],
+        currency: options[:currency]
       }
       PreferableClassMethods.declarations += 1
 
@@ -86,8 +135,76 @@ module Spree::Preferences
       end
     end
 
+    # Gives each named preference a plain reader, writer and predicate, so the
+    # API reads and writes `guest_checkout` rather than the DSL's
+    # `preferred_guest_checkout` — the methods Rails' `has_delegated_json`
+    # defines, so callers would not change if the storage ever moved to it.
+    # Grants no write access: each API controller still lists what it permits.
+    #
+    #   exposes_preferences :guest_checkout, :timezone
+    #
+    # @param names [Array<Symbol>]
+    # @return [void]
+    def exposes_preferences(*names)
+      names.each do |name|
+        name = name.to_sym
+        raise ArgumentError, "#{self.name} has no preference `#{name}` to expose" unless preference_definitions.key?(name)
+        raise ArgumentError, "#{self.name} cannot expose the preference `#{name}`: a method of that name exists" if method_defined?(name)
+
+        define_method(name) { public_send(:"preferred_#{name}") }
+        define_method(:"#{name}=") { |value| public_send(:"preferred_#{name}=", value) }
+        # As `has_json` defines one; a predicate the model already has (one
+        # that falls back to another setting, say) is kept.
+        define_method(:"#{name}?") { public_send(:"preferred_#{name}").present? } unless method_defined?(:"#{name}?")
+      end
+      self.exposed_preference_names = (exposed_preference_names | names.map(&:to_sym)).freeze
+    end
+
+    # The plain name an exposed preference goes by, for a key still using the
+    # DSL's `preferred_` prefix — an error key or a 5.x request parameter.
+    #
+    # @param key [Symbol, String] e.g. `preferred_guest_checkout`
+    # @return [Symbol, nil] e.g. `:guest_checkout`, or nil when the key names no exposed preference
+    def exposed_preference_name(key)
+      name = key.to_s.delete_prefix('preferred_')
+      name.to_sym if name != key.to_s && exposed_preference_names.include?(name.to_sym)
+    end
+
     private
 
+    # A declaration is the preference's contract on the wire. One Spree ships
+    # is always complete (a spec enforces it); an incomplete one from an
+    # extension still works in 6.0, with a schema that accepts any value.
+    def check_preference_declaration(name, type, options)
+      if options[:of] && type != :array
+        raise ArgumentError, "`of:` applies to an :array preference, not `#{name}` (#{type})"
+      end
+      if (options[:keys] || options[:values]) && type != :hash
+        raise ArgumentError, "`keys:` and `values:` apply to a :hash preference, not `#{name}` (#{type})"
+      end
+      [options[:of], options[:values], *options[:properties]&.values].compact.each do |item_type|
+        raise ArgumentError, "Unknown item type `#{item_type}` on preference `#{name}`" unless ITEM_TYPES.include?(item_type)
+      end
+      if options[:format] && !Spree::PreferenceSchema::JsonSchema::FORMATS.key?(options[:format])
+        raise ArgumentError, "Unknown format `#{options[:format]}` on preference `#{name}`"
+      end
+      raise ArgumentError, "`of: :id` needs `model:` on preference `#{name}`" if options[:of] == :id && options[:model].blank?
+      raise ArgumentError, "`currency:` applies to a :money preference, not `#{name}` (#{type})" if options[:currency] && type != :money
+      raise ArgumentError, "`of: :object` needs `properties:` on preference `#{name}`" if options[:of] == :object && options[:properties].blank?
+
+      missing = case type
+                when :any then 'a type other than :any'
+                when :array then '`of:`' unless options[:of]
+                when :hash then '`keys:` and `values:`' unless options[:keys] && options[:values]
+                end
+      return unless missing
+
+      Spree::Deprecation.warn(
+        "#{self.name} preference `#{name}` (#{type}) needs #{missing}; until it has one, its schema accepts any value. " \
+        'Spree 6.1 will raise for an incomplete declaration.'
+      )
+    end
+
     def own_preference_definitions
       @own_preference_definitions ||= {}
     end

data/lib/spree/core/ransack_configuration.rb

@@ -6,7 +6,7 @@ module Spree
   #
   # @example Adding custom searchable fields
   #   Spree.ransack.add_attribute(Spree::Product, :seller_id)
-  #   Spree.ransack.add_scope(Spree::Product, :by_seller)
+  #   Spree.ransack.add_scope(Spree::Product, :by_seller, type: 'id')
   #   Spree.ransack.add_association(Spree::Product, :seller)
   #
   class RansackConfiguration
@@ -14,6 +14,7 @@ module Spree
       @custom_attributes = Hash.new { |h, k| h[k] = [] }
       @custom_associations = Hash.new { |h, k| h[k] = [] }
       @custom_scopes = Hash.new { |h, k| h[k] = [] }
+      @custom_scope_types = Hash.new { |h, k| h[k] = {} }
     end
 
     # Add a custom ransackable attribute to a model.
@@ -38,8 +39,11 @@ module Spree
     #
     # @param model [Class] the model class to configure (e.g., Spree::Product)
     # @param scope [String, Symbol] the scope to add
+    # @param type [String, Array<String>, Hash, nil] the arguments it takes, as
+    #   in `ransackable_scope_types` — `'boolean'` for a scope taking none
     # @return [Array<String>] the updated list of custom scopes
-    def add_scope(model, scope)
+    def add_scope(model, scope, type: nil)
+      @custom_scope_types[model.name.to_sym][scope.to_s] = type unless type.nil?
       @custom_scopes[model.name.to_sym] |= [scope.to_s]
     end
 
@@ -67,6 +71,12 @@ module Spree
       @custom_scopes[model.name.to_sym]
     end
 
+    # @param model [Class] the model class to query
+    # @return [Hash{String => Object}] argument types declared with {#add_scope}
+    def custom_scope_types_for(model)
+      @custom_scope_types[model.name.to_sym]
+    end
+
     # Reset all custom configurations. Useful for testing.
     #
     # @return [void]
@@ -74,6 +84,7 @@ module Spree
       @custom_attributes.clear
       @custom_associations.clear
       @custom_scopes.clear
+      @custom_scope_types.clear
     end
   end
 end

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
-  VERSION = '6.0.0.rc1'.freeze
+  VERSION = '6.0.0.rc2'.freeze
 
   def self.version
     VERSION

data/lib/spree/core.rb

@@ -17,6 +17,7 @@ require 'awesome_nested_set'
 require 'cancan'
 require 'countries/global'
 require 'friendly_id'
+require 'json_schemer'
 require 'jwt'
 require 'liquid'
 require 'spree/core/emails/escaped_output'
@@ -251,7 +252,7 @@ module Spree
   # Example:
   #
   #   Spree.dependencies do |dependency|
-  #     dependency.cart_add_item_service = MyCustomAddToCart
+  #     dependency.cart_add_item_workflow = MyCustomAddToCart
   #   end
   #
   # This method is defined within the core gem on purpose.
@@ -542,10 +543,10 @@ module Spree
     # Dynamic methods for core dependencies
     #
     # @example Getting a dependency (returns resolved class)
-    #   Spree.cart_add_item_service.call(order: order, variant: variant)
+    #   Spree.cart_add_item_workflow.call(cart: cart, variant: variant)
     #
     # @example Setting a dependency
-    #   Spree.cart_add_item_service = MyApp::CartAddItem
+    #   Spree.cart_add_item_workflow = MyApp::CartAddItem
     def method_missing(method_name, *args, &block)
       base_name = method_name.to_s.chomp('=').to_sym
 
@@ -635,6 +636,7 @@ require 'spree/workflow'
 require 'spree/reporting'
 require 'spree/events'
 require 'spree/store_scope_guard'
+require 'spree/uploads'
 
 # Not autoloaded from app/: the registry keeps registered steps in
 # class-level state, which a reload would discard.
@@ -649,6 +651,7 @@ require 'spree/core/controller_helpers/store'
 
 require 'spree/core/preferences/runtime_configuration'
 require 'spree/core/preferences/masking'
+require 'spree/core/preferences/invalid_preferences'
 require 'spree/core/preferences/json_conversion'
 
 require 'spree/core/permission_configuration'

data/lib/spree/iso_data.rb

@@ -88,6 +88,13 @@ module Spree
                        freeze
       end
 
+      # The alpha-2 code of every orderable country, the closed list the API
+      # types publish as `CountryCode`.
+      # @return [Array<String>]
+      def country_codes
+        @country_codes ||= countries.map(&:alpha2).sort.freeze
+      end
+
       # @param code [String] alpha-2 or alpha-3 code, any case
       # @return [ISO3166::Country, nil]
       def country(code)

data/lib/spree/localized_number.rb

@@ -1,7 +1,13 @@
 module Spree
+  # Deprecated: Spree no longer parses numbers by locale. Its APIs take
+  # canonical decimal strings ("1234.56"); localizing input is the client's job.
   class LocalizedNumber
     # Strips all non-price-like characters from the number, taking into account locale settings.
     def self.parse(number)
+      Spree::Deprecation.warn(
+        'Spree::LocalizedNumber is deprecated and will be removed in Spree 6.1. ' \
+        'Parse a canonical decimal string with BigDecimal, or Spree::Money::Rounding.parse_canonical for API input.'
+      )
       return number unless number.is_a?(String)
 
       separator, delimiter = I18n.t([:'number.currency.format.separator', :'number.currency.format.delimiter'])

data/lib/spree/migrations.rb

@@ -29,8 +29,11 @@ module Spree
 
           name
         end.compact
+        installed = engine_in_app.map(&:camelize).to_set
 
-        missing_migrations = engine_migrations.sort - engine_in_app.sort
+        # Compared by class name: installing a migration writes its file name
+        # back from the class, so `decimal_19_4` is installed as `decimal194`.
+        missing_migrations = engine_migrations.sort.reject { |name| installed.include?(name.camelize) }
         unless missing_migrations.empty?
           puts "[#{engine_name.capitalize} WARNING] Missing migrations."
           missing_migrations.each do |migration|