spree_core 6.0.0.beta4 → 6.0.0.rc2

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

@@ -47,6 +47,25 @@ module Spree
         value.is_a?(String) && value.start_with?(TOKEN)
       end
 
+      # Money is written to at least the decimals of the currency the record
+      # names (a calculator's `currency` preference), keeping up to four like
+      # a unit price, so a per-item amount below a cent survives a round trip.
+      # A money preference with no currency of its own, such as an order-total
+      # rule that applies to any currency, keeps its exact decimal.
+      def self.wire_value(preferable, key, type, value)
+        case type
+        when :password then mask(value)
+        when :money
+          # Stored as the JSON text of a decimal.
+          amount = value.is_a?(String) ? BigDecimal(value, exception: false) : value
+          return value unless amount.is_a?(Numeric)
+
+          currency = preferable.money_preference_currency(key)
+          currency.present? ? Spree::Money::Rounding.format(amount, currency, unit_price: true) : Spree::Money::Rounding.format_decimal(amount)
+        else value
+        end
+      end
+
       # Serializes a Preferable's `preferences` hash for the wire,
       # masking `:password` values. Keys are stringified to match the
       # wire shape expected by JSON clients — schema entries built by
@@ -59,11 +78,45 @@ module Spree
       def self.serialize(preferable)
         return {} if preferable.nil?
 
+        definitions = preferable.class.preference_definitions
         preferable.preference_schema.each_with_object({}) do |field, hash|
-          value = preferable.preferences[field[:key]]
-          hash[field[:key_string] || field[:key].to_s] = field[:type] == :password ? mask(value) : value
+          # The stored value only, never the default — an unset secret must not
+          # reveal what it would fall back to — read through the record,
+          # because a secret lives in its own column.
+          value = preferable.stored_preference(field[:key]) { nil }
+          definition = definitions.fetch(field[:key])
+          hash[field[:key_string] || field[:key].to_s] =
+            if definition[:of] == :id
+              prefixed_ids(value, definition)
+            elsif %i[password money].include?(field[:type])
+              wire_value(preferable, field[:key], field[:type], value)
+            elsif definition[:keys] == :currency && definition[:values] == :money
+              money_by_currency(preferable.wire_preference_value(value, definition))
+            else
+              preferable.wire_preference_value(value, definition)
+            end
         end
       end
+
+      # Amounts keyed by currency (`{ "EUR" => "12.5" }`), each written with
+      # the decimals of its own currency, as every money value is.
+      def self.money_by_currency(value)
+        return value unless value.is_a?(Hash)
+
+        value.to_h do |currency, amount|
+          decimal = BigDecimal(amount.to_s, exception: false)
+          [currency, decimal ? Spree::Money::Rounding.format(decimal, currency, unit_price: true) : amount]
+        end
+      end
+
+      # Ids are stored as raw primary keys and leave as prefixed ids, the form
+      # every write accepts.
+      def self.prefixed_ids(value, definition)
+        return value unless value.is_a?(Array)
+
+        model = Spree::Preferences::Preferable.preference_model(definition)
+        value.map { |id| Spree::PrefixedId.prefixed_id?(id.to_s) ? id : model.prefixed_id_for(id) }
+      end
     end
   end
 end

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

@@ -1,84 +1,92 @@
-# Preferable allows defining preference accessor methods.
+# Typed model preferences, each a Rails store accessor on the `preferences`
+# JSON column — `secret_preferences` for a `:password` one (see
+# {Spree::SecretPreferences}). Included by `Spree::Base`.
 #
-# A class including Preferable must implement #preferences which should return
-# an object responding to .fetch(key), []=(key, val), and .delete(key).
-#
-# The generated writer method performs typecasting before assignment into the
-# preferences object.
-#
-# Examples:
-#
-#   # Spree::Base includes Preferable and defines preferences as a serialized
-#   # column.
 #   class Settings < Spree::Base
 #     preference :color,       :string,  default: 'red'
 #     preference :temperature, :integer, default: 21
 #   end
 #
 #   s = Settings.new
-#   s.preferred_color # => 'red'
-#   s.preferred_temperature # => 21
-#
-#   s.preferred_color = 'blue'
-#   s.preferred_color # => 'blue'
-#
-#   # Typecasting is performed on assignment
-#   s.preferred_temperature = '24'
-#   s.preferred_temperature # => 24
-#
-#   # Modifications have been made to the .preferences hash
-#   s.preferences #=> {color: 'blue', temperature: 24}
-#
-#   # Save the changes. All handled by activerecord
-#   s.save!
+#   s.preferred_color                # => 'red'
+#   s.preferred_temperature = '24'   # cast on assignment
+#   s.preferred_temperature          # => 24
+#   s.preferences                    # => { 'color' => 'red', 'temperature' => 24 }
 
 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, type: Hash, coder: YAML if defined?(serialize)
+    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
+  # back into a BigDecimal and a time. Anything else, or a string that does
+  # not parse, comes back as stored.
+  #
+  # @param value [Object] a value as JSON stores it
+  # @param type [Symbol] the preference's declared type
+  # @return [Object]
+  def self.restore_value(value, type)
+    return value unless value.is_a?(String)
+
+    case type
+    when :decimal, :money then BigDecimal(value, exception: false) || value
+    when :datetime then Time.zone.iso8601(value)
+    else value
+    end
+  rescue ArgumentError
+    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
-    send self.class.preference_getter_method(name)
+    public_send(:"preferred_#{name}")
   end
 
   def set_preference(name, value)
     has_preference! name
-    send self.class.preference_setter_method(name), value
+    public_send(:"preferred_#{name}=", value)
   end
 
   def preference_type(name)
-    has_preference! name
-    send self.class.preference_type_getter_method(name)
+    preference_definition(name)[:type]
   end
 
   def preference_default(name)
-    has_preference! name
-    send self.class.preference_default_getter_method(name)
+    instance_exec(&preference_definition(name)[:default])
   end
 
   def preference_deprecated(name)
-    has_preference! name
-    send(self.class.preference_deprecated_getter_method(name))
+    preference_definition(name)[:deprecated]
   end
 
   # Whether this preference is written by Spree rather than supplied by the
   # operator — a webhook secret a provider issues, say. Kept out of the
   # schema, so nothing offers it as a field to fill in.
   def preference_internal(name)
-    has_preference! name
-    getter = self.class.preference_internal_getter_method(name)
-    # A preference declared before this option existed has no such reader.
-    # Treated as not internal rather than raising, so one old declaration
-    # cannot take a whole class's preference schema down with it.
-    return false unless respond_to?(getter)
-
-    send(getter)
+    preference_definition(name)[:internal]
   end
 
   # The fixed set this preference's value must come from, when it has one.
@@ -87,14 +95,26 @@ module Spree::Preferences::Preferable
   #
   # @return [Array, nil]
   def preference_choices(name)
-    has_preference! name
-    getter = self.class.preference_choices_getter_method(name)
-    # A preference declared before this option existed has no such reader.
-    # Treated as unconstrained rather than raising, so one old declaration
-    # cannot take a whole class's preference schema down with it.
-    return unless respond_to?(getter)
+    choices = preference_definition(name)[:choices]
+    choices.respond_to?(:call) ? choices.call : choices
+  end
 
-    send(getter)
+  # 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)
@@ -102,92 +122,310 @@ module Spree::Preferences::Preferable
   end
 
   def has_preference?(name)
-    respond_to? self.class.preference_getter_method(name)
+    self.class.preference_definitions.key?(name.to_sym)
   end
 
   def defined_preferences
-    # Only real `preference`-macro definitions carry a `_default` getter —
-    # the name grep alone would also catch `preferred_*` association writers
-    # (e.g. Order#preferred_stock_location=).
-    methods.grep(/\Apreferred_.*=\Z/).filter_map do |pref_method|
-      name = pref_method.to_s.gsub(/\Apreferred_|=\Z/, '').to_sym
-      name if respond_to?(self.class.preference_default_getter_method(name))
+    self.class.preference_definitions.keys
+  end
+
+  def default_preferences
+    defined_preferences.index_with { |name| preference_default(name) }
+  end
+
+  # Every preference value, secrets included — what `preferences` alone held
+  # before secrets moved to their own column. Declared preferences read
+  # through their `preferred_*` reader, so a default applies and decimals and
+  # times come back typed rather than in the string form JSON stores.
+  #
+  # @return [ActiveSupport::HashWithIndifferentAccess]
+  def preference_values
+    (preferences || {}).to_h.with_indifferent_access.merge(defined_preferences.index_with { |name| get_preference(name) })
+  end
+
+  # The stored value of a preference, before its default applies. A secret
+  # found in `preferences` wins over the encrypted column: it is either a
+  # newer value assigned as part of a whole hash, waiting for the save that
+  # moves it across, or one the upgrade has not moved yet — the writer always
+  # removes that copy, so it is never stale.
+  #
+  # @param name [Symbol, String]
+  # @return [Object] the stored value, or the block's result when nothing is stored
+  def stored_preference(name)
+    if secret_preference?(name)
+      (preferences || {}).fetch(name) { (secret_preferences || {}).fetch(name) { return yield } }
+    else
+      (preferences || {}).fetch(name) { yield }
     end
   end
 
-  def deprecated_preferences
-    defined_preferences.each_with_object([]) do |pref_name, array|
-      deprecated_message = preference_deprecated(pref_name)
-      array << { name: pref_name, message: deprecated_message } unless deprecated_message.nil?
+  # Fills in the declared default of every preference this record has no
+  # stored value for, so a preference added to the class after the row was
+  # saved never reads as missing and the raw `preferences` hash always holds
+  # every value. Secrets are left out: their defaults are read through the
+  # `preferred_*` reader, never copied into storage.
+  #
+  # Filling in a default is not a change to a stored record: a loaded record
+  # stays clean, so `with_lock` still accepts it, and the defaults are written
+  # with its next real save.
+  def backfill_default_preferences
+    secrets = self.class.secret_preference_names
+    missing = defined_preferences.reject { |name| preferences.key?(name) || secrets.include?(name) }
+    return if missing.empty?
+
+    already_changed = attribute_changed?(:preferences)
+    self.preferences = preferences.merge(missing.index_with { |name| stored_default(name) })
+    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
 
-  def default_preferences
-    Hash[
-      defined_preferences.map do |preference|
-        [preference, preference_default(preference)]
+  # 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>]
+  def previously_changed_preference_names
+    defined_preferences.select { |name| public_send(:"saved_change_to_preferred_#{name}?") }
+  end
+
+  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]
+  end
+
+  # A declared default in the form JSON stores, as the writer would store it,
+  # so a decimal default reads back as a BigDecimal and setting the same
+  # amount is not a change.
+  def stored_default(name)
+    default = preference_default(name)
+    type = preference_type(name)
+    return default if default.nil? || %i[decimal money datetime].exclude?(type)
+
+    convert_preference_value(default, type, nullable: true).as_json
+  end
+
+  # Only a class that stores secrets can declare one, so the names say it all.
+  def secret_preference?(name)
+    self.class.secret_preference_names.include?(name.to_sym)
+  end
+
+  def cast_preference(name, value)
+    definition = preference_definition(name)
+    parse_on_set = definition[:parse_on_set]
+    if parse_on_set.is_a?(Proc)
+      # Procs that accept more than one arg opt into receiving the owning
+      # record so they can scope (e.g. `normalize_id_preference` rejecting
+      # cross-store IDs). `arity.abs > 1` covers both the `(value, owner)` and
+      # `(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 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
 
-  def preferences_of_type(type)
-    defined_preferences.find_all { |preference| preference_type(preference) == type.to_sym }
+  # 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 clear_preferences
-    preferences.keys.each { |pref| preferences.delete pref }
+  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 restore_preferences_for(preference_keys)
-    preference_keys.each { |pref| preferences[pref] = preference_default(pref) }
+  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
 
-  def preference_change(name, changes_or_previous_changes)
-    preference_changes = changes_or_previous_changes.with_indifferent_access.fetch('preferences', [{}, {}])
-    before_preferences = preference_changes[0] || {}
-    after_preferences = preference_changes[1] || {}
+  # 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
 
-    return if before_preferences[name] == after_preferences[name]
+    ids
+  end
 
-    [before_preferences[name], after_preferences[name]]
+  # 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.
+  def write_preference(name, value)
+    if secret_preference?(name)
+      # A copy assigned as part of a whole hash would otherwise outlive the
+      # value written here and be moved over it on save.
+      self.preferences = preferences.except(name) if preferences&.key?(name)
+      self.secret_preferences = (secret_preferences || {}).with_indifferent_access.merge(name => value)
+    else
+      self.preferences = (preferences || {}).with_indifferent_access.merge(name => value)
+    end
   end
 
-  private
+  # 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)
@@ -195,6 +433,8 @@ module Spree::Preferences::Preferable
       case value.class.to_s
       when 'Hash'
         value
+      when 'ActionController::Parameters'
+        value.to_h
       when 'String'
         # only works with hashes whose keys are strings
         JSON.parse value.gsub('=>', ':')
@@ -221,7 +461,7 @@ module Spree::Preferences::Preferable
         value.to_time
       end
     # Kept as the `yyyy-MM-dd` string it arrived as rather than coerced to a
-    # Time. Preferences are YAML-serialized, and what a date *means* depends on
+    # Time. Preferences are stored as JSON, and what a date *means* depends on
     # the store's timezone, which this method has no access to: coercing here
     # would freeze the value against the server's zone and move the operator's
     # deadline by hours. The reader owns that (see