spree_core 6.0.0.rc1 → 6.0.0.rc2

data/app/services/spree/orders/create.rb

@@ -45,7 +45,7 @@ module Spree
       rescue ActiveRecord::RecordInvalid => e
         failure(e.record, e.record.errors.full_messages.to_sentence)
       rescue ActiveStorage::FileNotFoundError
-        # An abandoned direct upload leaves the blob row without its bytes.
+        # An abandoned presigned upload leaves the blob row without its bytes.
         # ActiveStorage raises a message-less error for that, which would
         # otherwise be an unhandled 500 on the Admin API.
         order ||= @store.orders.new
@@ -71,8 +71,8 @@ module Spree
         }
 
         # The buyer's purchase order, when it arrived with the paperwork. A
-        # signed blob id, so it assigns like any other attribute.
-        attrs[:po_document] = @params[:po_document] if @params[:po_document].present?
+        # signed id, so it assigns like any other attribute.
+        attrs[:po_document_signed_id] = @params[:po_document_signed_id] if @params[:po_document_signed_id].present?
 
         attrs[:market] = resolve_market if @params[:market_id].present?
         attrs[:channel] = resolve_channel if @params[:channel_id].present?

data/app/services/spree/orders/discounts/create.rb

@@ -17,8 +17,8 @@ module Spree
         # @param line_item [Spree::LineItem, nil] nil distributes order-level
         # @return [Spree::ServiceModule::Result] value is the created rows
         def call(order:, label:, value:, value_type: 'flat', line_item: nil)
-          value = BigDecimal(value.to_s)
-          return failure(nil, I18n.t('spree.errors.messages.discount_value_must_be_positive')) unless value.positive?
+          value = Spree::Money::Rounding.parse_decimal(value)
+          return failure(nil, I18n.t('spree.errors.messages.discount_value_must_be_positive')) unless value&.positive?
           return failure(nil, I18n.t('spree.errors.messages.discount_value_type_invalid')) unless %w[flat percent].include?(value_type)
 
           rows = order.with_lock do
@@ -39,7 +39,7 @@ module Spree
 
         def line_item_row(order, line_item, label, value, value_type)
           base = discountable_base(line_item)
-          amount = -[amount_for(base, value, value_type), base].min
+          amount = -[amount_for(base, value, value_type, order.currency), base].min
           return if amount.zero?
 
           create_row(order, line_item, label, amount, value, value_type)
@@ -51,19 +51,19 @@ module Spree
           bases_sum = bases.sum
           return [] if bases_sum <= 0
 
-          total = [amount_for(bases_sum, value, value_type), bases_sum].min
-          shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares((total * 100).round, bases)
+          total = [amount_for(bases_sum, value, value_type, order.currency), bases_sum].min
+          shares = Spree::Adjusters::LargestRemainder.apportion(total, bases, order.currency)
 
           line_items.each_with_index.filter_map do |line_item, index|
-            amount = -BigDecimal(shares[index]) / 100
+            amount = -shares[index]
             next if amount.zero?
 
             create_row(order, line_item, label, amount, value, value_type)
           end
         end
 
-        def amount_for(base, value, value_type)
-          value_type == 'percent' ? (base * value / 100).round(2) : value
+        def amount_for(base, value, value_type, currency)
+          Spree::Money::Rounding.to_currency(value_type == 'percent' ? base * value / 100 : value, currency)
         end
 
         # Remaining discountable base: amount net of already-applied discounts.

data/app/services/spree/prices/bulk_upsert.rb

@@ -44,9 +44,12 @@ module Spree
       #   (docs/plans/6.0-volume-pricing.md).
       def call(rows:)
         rows = Array(rows).map { |r| r.with_indifferent_access }
-        # Amounts are parsed once, here; everything below reads numbers.
         keyed = rows.select { |r| r[:variant_id].present? && r[:currency].present? }
-                    .map { |r| r.merge(amount: parse_amount(r[:amount]), compare_at_amount: parse_amount(r[:compare_at_amount])) }
+        unreadable = rows_with_malformed_amount(keyed)
+        return failure(nil, malformed_amounts: unreadable) if unreadable.any?
+
+        # Amounts are parsed once, here; everything below reads numbers.
+        keyed = keyed.map { |r| r.merge(amount: Spree::Money::Rounding.parse_decimal(r[:amount]), compare_at_amount: Spree::Money::Rounding.parse_decimal(r[:compare_at_amount])) }
         # Checked before anything is deduped: `row_key` coerces the quantity,
         # so two malformed rows would collapse into one and the batch would be
         # judged on a shape the caller never sent.
@@ -98,12 +101,13 @@ module Spree
             upsert_batch(base_rows, BASE_UNIQUE_BY)
           end
           upsert_batch(override_rows, OVERRIDE_UNIQUE_BY)
-          sweep(affected_keys, clear_rows)
+          cleared_variant_ids = sweep(affected_keys, clear_rows)
           # `upsert_all` and `delete_all` both skip AR callbacks, so the
           # `Price -> Variant -> Product` `touch:` chain never fires —
           # downstream caches (`cache_key_with_version`) would stay stale.
-          # Re-trigger the chain with one `.touch` per affected variant.
-          touch_variants(affected_keys.map { |k| k[0] }.uniq)
+          # A blank row clearing a rung that had no amount changes nothing,
+          # so only priced rows and cleared amounts touch their variant.
+          touch_variants((upsert_rows.map { |r| r[:variant_id].to_s } + cleared_variant_ids).uniq)
         end
 
         success(price_count: payload.length)
@@ -167,6 +171,18 @@ module Spree
         Integer(raw.to_s.strip, 10, exception: false)
       end
 
+      # Rows whose amount is not a number or plain decimal text ("1,599.99",
+      # `false`), refused before a malformed value can read as "clear".
+      def rows_with_malformed_amount(rows)
+        rows.each_with_index.filter_map do |row, index|
+          Spree::Money::Rounding.parse_decimal(row[:amount])
+          Spree::Money::Rounding.parse_decimal(row[:compare_at_amount])
+          nil
+        rescue Spree::Money::InvalidFormat
+          { index: index }
+        end
+      end
+
       # Rows pricing below zero. This path runs no model validations, so the
       # sign is checked here for every caller rather than in each of them.
       def rows_with_negative_amount(rows)
@@ -370,15 +386,6 @@ module Spree
         [row[:variant_id].to_s, row[:currency], row[:price_list_id].to_s]
       end
 
-      # Parses locale-aware decimal input ("1.234,56" in DE, "1,234.56"
-      # in en-US). Numeric values pass through; blank values become nil.
-      def parse_amount(value)
-        return nil if value.blank?
-        return value if value.is_a?(Numeric)
-
-        Spree::LocalizedNumber.parse(value)
-      end
-
       def sweep(affected_keys, clear_rows)
         cleared_keys = clear_rows.map { |r| row_key(r) }.to_set
         affected_set = affected_keys.to_set
@@ -392,16 +399,14 @@ module Spree
           )
           .pluck(:id, :variant_id, :currency, :price_list_id, :min_quantity, :amount)
 
-        doomed_ids = candidates.filter_map do |id, variant_id, currency, price_list_id, min_quantity, amount|
+        doomed = candidates.select do |_, variant_id, currency, price_list_id, min_quantity, amount|
           key = [variant_id.to_s, currency, price_list_id&.to_s, min_quantity]
-          next unless affected_set.include?(key)
-          next id if amount.nil?
-          next id if cleared_keys.include?(key)
-
-          nil
+          affected_set.include?(key) && (amount.nil? || cleared_keys.include?(key))
         end
 
-        Spree::Price.where(id: doomed_ids).delete_all if doomed_ids.any?
+        Spree::Price.where(id: doomed.map(&:first)).delete_all if doomed.any?
+
+        doomed.filter_map { |_, variant_id, *, amount| variant_id.to_s if amount }
       end
 
       # Bumps `updated_at` on the affected variants and their parent
@@ -410,15 +415,17 @@ module Spree
       # `Variant -> Product` `touch:` chains otherwise.
       #
       # We use `touch_all` rather than per-record `Variant#touch`: it bumps
-      # every affected row in a single UPDATE and skips AR callbacks, giving
-      # the cache bust without extra side effects.
+      # every affected row in a single UPDATE. It also skips the product's
+      # commit callbacks, so the search index, which stores prices, is
+      # refreshed here.
       def touch_variants(variant_ids)
         return if variant_ids.empty?
 
         variants = Spree::Variant.where(id: variant_ids)
-        product_ids = variants.pluck(:product_id).uniq
+        products = Spree::Product.where(id: variants.select(:product_id))
         variants.touch_all
-        Spree::Product.where(id: product_ids).touch_all if product_ids.any?
+        products.touch_all
+        products.find_each(&:enqueue_search_index)
       end
 
       # MySQL infers conflict targets from its own unique indexes and

data/app/services/spree/seeds/stores.rb

@@ -14,7 +14,7 @@ module Spree
           s.customer_support_email       = 'support@example.com'
           s.default_currency             = 'USD'
           s.default_country_code          = 'US'
-          s.default_locale               = I18n.locale
+          s.default_locale               = Spree::Locales.listed(I18n.locale) || 'en'
         end.save!
       end
     end

data/app/services/spree/stores/provision_defaults.rb

@@ -18,8 +18,9 @@ module Spree
 
       # @param store [Spree::Store] the store to provision, already persisted
       # @param country [Spree::Country] where the shop ships from
-      # @param locale [String, nil] storefront locale; defaults to the
-      #   country's own language when Spree translates it, then English
+      # @param locale [String, nil] storefront locale, a code from
+      #   `Spree::Locales::ALL` (another spelling or region moves to the listed
+      #   one); defaults to the country's own language, then English
       # @param currency [String, nil] ISO 4217 code; defaults to the country's
       #   own currency. Merchants who ship from one country and price in
       #   another currency pass it explicitly.
@@ -55,21 +56,17 @@ module Spree
         found&.iso_code || country.default_currency.presence || 'USD'
       end
 
-      # An explicit locale is honored as given — a host app may ship its own
-      # translations. Only the *derived* default is filtered: falling back to
-      # a country's official language that Spree has no strings for would set
-      # a storefront to a language with nothing behind it, and it is not one
-      # the setup screen ever offers.
+      # A store's locale is a content locale, so it comes from
+      # `Spree::Locales::ALL` whether or not Spree ships translations for it:
+      # the storefront and dashboard carry their own. An explicit locale is
+      # kept when it is listed, or moved to its listed language (`en-IE`
+      # becomes `en`); one Spree cannot place, or none, gives the country's
+      # first official language Spree lists.
       def resolve_locale(requested, country)
-        return requested if requested.present?
+        listed = Spree::Locales.listed(requested)
+        return listed if listed
 
-        derived = country.default_locale.presence
-        return 'en' if derived.blank?
-
-        locales = Spree.available_locales
-        Spree.locale_for_language(derived, locales) ||
-          country.official_locales.lazy.filter_map { |language| Spree.locale_for_language(language, locales) }.first ||
-          'en'
+        [country.default_locale, *country.official_locales].lazy.filter_map { |language| Spree::Locales.for_language(language) }.first || 'en'
       end
 
       # The store's own country/currency/locale columns are not the source of
@@ -260,7 +257,7 @@ module Spree
           calculator = delivery_method.calculator
           next unless calculator.respond_to?(:preferred_currency)
           next if calculator.preferred_currency == currency
-          next unless calculator.preferences[:amount].to_f.zero?
+          next unless Spree::Money::Rounding.blank_or_zero?(calculator.preferences[:amount])
 
           calculator.update!(preferences: calculator.preferences.merge(currency: currency))
         end

data/app/services/spree/update_check.rb

@@ -0,0 +1,160 @@
+require 'net/http'
+
+module Spree
+  # Asks spreecloud.io which Spree releases are newer than the running one,
+  # and reports usage with the same request. The answer is cached for a day,
+  # so at most one admin request a day waits on it, for no more than the two
+  # one-second timeouts. A failed check is cached for an hour, so a passing
+  # outage costs one slow request an hour and never hides a release for long.
+  #
+  # The +version+, +environment+, +url+ and +install_id+ query keys are what
+  # Spree 5 sent, and the endpoint still serves 5.x installs with them. They
+  # are never renamed; new keys only ever go beside them.
+  class UpdateCheck
+    ENDPOINT = 'https://spreecloud.io/updates.json'.freeze
+    RELEASES_URL = 'https://github.com/spree/spree/releases/tag/'.freeze
+    RELEASE_TAG = /\Av\d+(\.[0-9a-z]+)*\z/
+    CACHE_TTL = 1.day
+    FAILURE_TTL = 1.hour
+    OPEN_TIMEOUT = 1
+    READ_TIMEOUT = 1
+    # The read timeout applies to each read, not the whole response, so a
+    # slowly trickling answer needs an overall deadline as well.
+    TOTAL_TIMEOUT = 2
+    # Order-of-magnitude buckets: enough to tell a hobby install from a large
+    # merchant, never an exact figure.
+    BUCKETS = {
+      0..0 => '0',
+      1..9 => '1-9',
+      10..99 => '10-99',
+      100..999 => '100-999',
+      1_000..9_999 => '1k-9k',
+      10_000..99_999 => '10k-99k'
+    }.freeze
+    LARGEST_BUCKET = '100k+'.freeze
+
+    class << self
+      # @return [Boolean] false when the operator turned the check off
+      def enabled?
+        Spree::Config.update_check_enabled && !env_flag?('SPREE_UPDATE_CHECK_DISABLED')
+      end
+
+      # When false, the check still runs but sends the running version only.
+      #
+      # @return [Boolean]
+      def telemetry_enabled?
+        Spree::Config.telemetry_enabled &&
+          !env_flag?('SPREE_TELEMETRY_DISABLED') &&
+          !env_flag?('DO_NOT_TRACK')
+      end
+
+      # The cached answer, fetched from the endpoint when there is none.
+      #
+      # @return [Spree::UpdateStatus]
+      def status
+        return Spree::UpdateStatus.new(current_version: Spree.version, enabled: false) unless enabled?
+
+        result = Rails.cache.read(cache_key) || refresh
+
+        Spree::UpdateStatus.new(current_version: Spree.version, checked_at: result[:checked_at], releases: result[:releases])
+      end
+
+      # @return [Hash] the query string the endpoint receives
+      def query
+        return { version: Spree.version } unless telemetry_enabled?
+
+        {
+          version: Spree.version,
+          environment: Rails.env,
+          url: Spree::Store.default&.storefront_url,
+          install_id: Spree.install_id,
+          ruby: RUBY_VERSION,
+          rails: Rails.version,
+          database: ActiveRecord::Base.connection_db_config.adapter,
+          gems: Gem.loaded_specs.keys.grep(/\Aspree_/).sort.join(','),
+          dashboard: dashboard_served?,
+          stores: bucket(Spree::Store.count),
+          products: bucket(Spree::Product.count),
+          orders: bucket(Spree::Order.complete.count),
+          sellers: seller_bucket
+        }.compact
+      end
+
+      private
+
+      def refresh
+        releases = fetch_releases
+        result = { releases: releases || [], checked_at: Time.current }
+        Rails.cache.write(cache_key, result, expires_in: releases ? CACHE_TTL : FAILURE_TTL)
+        result
+      end
+
+      # Nil when the check failed, for whatever reason: an update notice is
+      # never worth failing the admin's request over, including a database
+      # error while counting for the usage fields.
+      def fetch_releases
+        uri = URI(ENDPOINT)
+        uri.query = URI.encode_www_form(query)
+
+        response = Timeout.timeout(TOTAL_TIMEOUT) do
+          Net::HTTP.start(uri.host, uri.port, use_ssl: true, max_retries: 0,
+                                              open_timeout: OPEN_TIMEOUT, read_timeout: READ_TIMEOUT) do |http|
+            http.get(uri.request_uri)
+          end
+        end
+        return unless response.is_a?(Net::HTTPSuccess)
+
+        newer_releases(JSON.parse(response.body))
+      rescue StandardError => e
+        Rails.error.report(e, handled: true, severity: :warning, source: 'spree.update_check')
+        nil
+      end
+
+      # The endpoint already filters by version; this does it again and
+      # builds each link from the tag, so whatever comes back over the wire
+      # never reaches the dashboard as a URL. Release candidates are only
+      # offered to installs already running one.
+      def newer_releases(payload)
+        current = Gem::Version.new(Spree.version)
+
+        Array(payload).filter_map { |release|
+          tag = release.is_a?(Hash) ? release['tag_name'].to_s : ''
+          next unless tag.match?(RELEASE_TAG)
+
+          version = Gem::Version.new(tag.delete_prefix('v'))
+          next unless version > current
+          next if version.prerelease? && !current.prerelease?
+
+          { version: version.to_s, url: "#{RELEASES_URL}#{tag}", published_at: parse_time(release['published_at']) }
+        }.sort_by { |release| Gem::Version.new(release[:version]) }.reverse
+      end
+
+      def parse_time(value)
+        Time.iso8601(value.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def bucket(count)
+        BUCKETS.find { |range, _| range.cover?(count) }&.last || LARGEST_BUCKET
+      end
+
+      def seller_bucket
+        count = Spree::Seller.count
+        bucket(count) if count.positive?
+      end
+
+      def dashboard_served?
+        (defined?(Spree::Dashboard) && Spree::Dashboard.dist_path.present?) || Spree::Config.dashboard_url.present?
+      end
+
+      def env_flag?(name)
+        ActiveModel::Type::Boolean.new.cast(ENV[name].presence) == true
+      end
+
+      def cache_key
+        "spree/update_check/#{Spree.version}"
+      end
+    end
+  end
+end

data/app/services/spree/uploads/assign_stores.rb

@@ -0,0 +1,92 @@
+module Spree
+  module Uploads
+    # Gives every attached file that has no store the store of the record it
+    # is attached to (the 6.0 upgrade, `spree:uploads:assign_stores`).
+    #
+    # Owners with a `store_id` column are handled with one set-based update per
+    # attachment type; the rest (a variant's digital file, a seller's
+    # submission) ask {Spree::Uploads.store_id_for} record by record. Files
+    # attached nowhere keep no store, and the daily purge leaves them alone.
+    #
+    # Safe to re-run: only files without a store are touched.
+    class AssignStores
+      prepend Spree::ServiceModule::Base
+
+      BATCH_SIZE = 1_000
+
+      # @return [Spree::ServiceModule::Result] a hash with `assigned`, the
+      #   number of files given a store, and `conflicts`, the ids of files
+      #   attached to records of more than one store, which are reported and
+      #   left for a person to resolve
+      def call
+        assigned = record_types.sum do |record_type|
+          owner_class = record_type.safe_constantize
+          next 0 if owner_class.nil?
+
+          # Renditions and previews are blobs themselves: a set-based update
+          # would join the table it updates, which MySQL refuses.
+          if owner_class.column_names.include?('store_id') && !record_type.start_with?('ActiveStorage::')
+            assign_from_store_column(record_type, owner_class)
+          else
+            assign_record_by_record(record_type)
+          end
+        end
+
+        success(assigned: assigned, conflicts: conflicting_blob_ids)
+      end
+
+      private
+
+      # Renditions and previews take their store from their original file, so
+      # they go last, once the originals have one.
+      def record_types
+        ActiveStorage::Attachment.distinct.pluck(:record_type).
+          sort_by { |record_type| [record_type.start_with?('ActiveStorage::') ? 1 : 0, record_type] }
+      end
+
+      # Correlated subqueries rather than UPDATE … FROM, which MySQL and SQLite
+      # spell differently. Several attachments of one file in different stores
+      # pick one; {#conflicting_blob_ids} reports them.
+      def assign_from_store_column(record_type, owner_class)
+        attachments_table = ActiveStorage::Attachment.table_name
+        owners_table = owner_class.table_name
+        owner_store = ActiveStorage::Attachment.
+                      joins("INNER JOIN #{owners_table} ON #{owners_table}.id = #{attachments_table}.record_id").
+                      where(record_type: record_type).
+                      where("#{attachments_table}.blob_id = #{ActiveStorage::Blob.table_name}.id").
+                      where.not(owners_table => { store_id: nil })
+
+        ActiveStorage::Blob.where(store_id: nil).
+          where(id: ActiveStorage::Attachment.where(record_type: record_type).select(:blob_id)).
+          where(owner_store.arel.exists).
+          update_all(["store_id = (#{owner_store.select("#{owners_table}.store_id").limit(1).to_sql})"])
+      end
+
+      # One update per store and batch rather than per file.
+      def assign_record_by_record(record_type)
+        unassigned = ActiveStorage::Attachment.joins(:blob).
+                     where(record_type: record_type, ActiveStorage::Blob.table_name => { store_id: nil })
+
+        unassigned.preload(:record).in_batches(of: BATCH_SIZE).sum do |batch|
+          batch.select(&:record).group_by { |attachment| Spree::Uploads.store_id_for(attachment.record) }.sum do |store_id, owned|
+            next 0 if store_id.nil?
+
+            ActiveStorage::Blob.where(id: owned.map(&:blob_id), store_id: nil).update_all(store_id: store_id)
+          end
+        end
+      end
+
+      def conflicting_blob_ids
+        resolvable_types = record_types.select(&:safe_constantize)
+        shared_blob_ids = ActiveStorage::Attachment.where(record_type: resolvable_types).group(:blob_id).having('COUNT(*) > 1').pluck(:blob_id)
+
+        shared_blob_ids.each_slice(BATCH_SIZE).flat_map do |blob_ids|
+          ActiveStorage::Attachment.where(blob_id: blob_ids, record_type: resolvable_types).includes(:record).group_by(&:blob_id).filter_map do |blob_id, blob_attachments|
+            store_ids = blob_attachments.filter_map { |attachment| attachment.record && Spree::Uploads.store_id_for(attachment.record) }
+            blob_id if store_ids.map(&:to_s).uniq.size > 1
+          end
+        end
+      end
+    end
+  end
+end

data/app/validators/spree/attachment_content_type_validator.rb

@@ -44,6 +44,16 @@ module Spree
     # identified outright and never reaches the tie-break at all.
     CONTAINER_CONTENT_TYPES = %w[application/zip application/x-ole-storage].freeze
 
+    # Plain-text formats carry no signature at all, so the bytes can only prove
+    # what they are not. Marcel names anything it recognises — HTML, XML, SVG,
+    # scripts with a shebang, executables — and those never reach this
+    # tie-break. What is left is accepted under a text extension only when it
+    # is free of the control bytes every binary format carries. No particular
+    # encoding is required, since spreadsheet tools still export in legacy ones.
+    TEXT_CONTENT_TYPES = %w[text/csv].freeze
+    UNIDENTIFIED_CONTENT_TYPES = %w[application/octet-stream text/plain].freeze
+    BINARY_BYTES = /[\x00-\x08\x0B\x0E-\x1F\x7F]/n
+
     # A misspelled or forgotten option would otherwise leave this validator
     # silently accepting everything, on the one path whose whole purpose is
     # refusing hostile files. An allowlist that resolves to empty at runtime is
@@ -116,9 +126,16 @@ module Spree
       # read, which would hand the decision back to whoever uploaded the file.
       detected = Marcel::MimeType.for(StringIO.new(head))
       return true if permitted.include?(detected)
+      return permitted_plain_text?(blob, head, permitted) if UNIDENTIFIED_CONTENT_TYPES.include?(detected)
       return false unless CONTAINER_CONTENT_TYPES.include?(detected)
 
-      permitted.include?(office_type_from_extension(blob))
+      permitted.include?(type_from_extension(blob))
+    end
+
+    def permitted_plain_text?(blob, head, permitted)
+      text_type = type_from_extension(blob)
+
+      TEXT_CONTENT_TYPES.include?(text_type) && permitted.include?(text_type) && !head.b.match?(BINARY_BYTES)
     end
 
     # Asks the extension alone, rather than re-reading the bytes with a filename
@@ -129,7 +146,7 @@ module Spree
     # bytes we read.
     #
     # @return [String, nil]
-    def office_type_from_extension(blob)
+    def type_from_extension(blob)
       filename = blob.filename.to_s
       return if File.extname(filename).blank?
 

data/app/validators/spree/locale_codes_validator.rb

@@ -0,0 +1,22 @@
+module Spree
+  # Rejects locale codes `Spree::Locales::ALL` does not list, in a single code
+  # or a comma-separated list, naming the ones it refuses. Reads the stored
+  # column, since a store answers `default_locale` from its default market,
+  # and checks only an attribute that is changing, so a record saved before
+  # the list was enforced can still be edited.
+  #
+  # @example
+  #   validates_with Spree::LocaleCodesValidator, attributes: %i[default_locale supported_locales]
+  class LocaleCodesValidator < ActiveModel::Validator
+    def validate(record)
+      Array(options[:attributes]).each do |attribute|
+        next unless record.will_save_change_to_attribute?(attribute)
+
+        unlisted = Spree::Locales.unlisted(record.read_attribute(attribute))
+        next if unlisted.empty?
+
+        record.errors.add(attribute, I18n.t('spree.locales_not_listed', codes: unlisted.join(', ')))
+      end
+    end
+  end
+end

data/app/workflows/spree/fulfillments/create.rb

@@ -320,8 +320,8 @@ module Spree
       end
 
       # Strict decimal parsing (same semantics as Shipment#cost=, which the
-      # update_columns freeze path bypasses) — the lenient LocalizedNumber
-      # would turn garbage into 0, and 0 is a legal cost here.
+      # update_columns freeze path bypasses) — a lenient parse would turn
+      # garbage into 0, and 0 is a legal cost here.
       #
       # @return [BigDecimal, Numeric, nil] nil when no cost was given (blank
       #   counts as omitted); a failure Result for malformed or negative input

data/app/workflows/spree/payments/capture.rb

@@ -14,11 +14,13 @@ module Spree
       hooks :validate, :before_capture, :after_capture
 
       # @param payment [Spree::Payment] a completed payment is a no-op
-      # @param amount [Integer, nil] amount in cents; nil captures in full,
-      #   a smaller amount splits the remainder into a new pending payment
+      # @param amount [BigDecimal, nil] in the currency's own units; nil
+      #   captures in full, a smaller amount splits the remainder into a new
+      #   pending payment. An Integer is read as hundredths of the currency,
+      #   the pre-6.0 contract (deprecated, removed in 6.1).
       def perform(payment:, amount: nil)
         super
-        @amount = amount || payment.money.amount_in_cents
+        @amount = capture_amount(amount)
 
         step :ensure_capturable
         # Veto point — fraud holds, manual review. Before any money moves.
@@ -44,6 +46,17 @@ module Spree
 
       attr_reader :response, :remainder
 
+      def capture_amount(amount)
+        return payment.amount if amount.nil?
+        return Spree::Money::Rounding.to_currency(amount, payment.currency) unless amount.is_a?(Integer)
+
+        Spree::Deprecation.warn(
+          'Passing an Integer amount to the payment capture workflow is deprecated and is read as hundredths of ' \
+          'the currency. Pass the amount in the currency\'s own units as a BigDecimal; removed in Spree 6.1.'
+        )
+        Spree::Money::Rounding.from_hundredths(amount)
+      end
+
       # An already-captured payment returns success rather than failing:
       # capture is naturally idempotent and double-submitted admin actions
       # must not surface as errors. A failed payment is capturable — the
@@ -65,7 +78,9 @@ module Spree
       def capture_at_gateway
         @response = payment.protect_from_connection_error do
           instrument_gateway_call(:capture, payment.payment_method) do
-            payment.payment_method.capture(@amount, payment.response_code, payment.gateway_options)
+            payment.payment_method.capture(
+              payment.payment_method.gateway_amount(@amount, payment.currency), payment.response_code, payment.gateway_options
+            )
           end
         end
 
@@ -86,7 +101,7 @@ module Spree
           if Spree::Payment.where(id: payment.id, status: 'completed').exists?
             already_captured = true
           else
-            payment.capture_events.create!(amount: ::Money.new(@amount, payment.currency).to_f)
+            payment.capture_events.create!(amount: @amount)
             # Split before completing, so payment.completed publishes with
             # the captured amount and the order recomputes from correct rows.
             @remainder = payment.split_uncaptured_amount

data/app/workflows/spree/payments/process.rb

@@ -57,7 +57,9 @@ module Spree
 
         response = payment.protect_from_connection_error do
           instrument_gateway_call(verb, payment.payment_method) do
-            payment.payment_method.public_send(verb, payment.money.amount_in_cents, payment.source, payment.gateway_options)
+            payment.payment_method.public_send(
+              verb, payment.payment_method.gateway_amount(payment.amount, payment.currency), payment.source, payment.gateway_options
+            )
           end
         end
 

data/app/workflows/spree/price_lists/update.rb

@@ -61,7 +61,9 @@ module Spree
         unless result.success?
           refusal = result.error&.value
           refusal = {} unless refusal.is_a?(Hash)
-          if refusal[:invalid_amounts].present?
+          if refusal[:malformed_amounts].present?
+            price_list.errors.add(:base, :malformed_price)
+          elsif refusal[:invalid_amounts].present?
             price_list.errors.add(:base, :negative_price)
           elsif refusal[:invalid_quantities].present?
             price_list.errors.add(:base, :invalid_quantity)
@@ -76,12 +78,10 @@ module Spree
           end
           return failure(price_list)
         end
-
-        touch_variants(rows.map { |row| row[:variant_id] }.uniq)
       end
 
       def clear_prices
-        variant_ids = price_list.prices.distinct.pluck(:variant_id)
+        variant_ids = price_list.prices.where.not(amount: nil).distinct.pluck(:variant_id)
         price_list.prices.update_all(amount: nil, compare_at_amount: nil, updated_at: Time.current)
         touch_variants(variant_ids)
       end