spree_core 6.0.0.beta4 → 6.0.0.rc2

data/app/models/concerns/spree/typed_adjustment_line.rb

@@ -1,11 +1,14 @@
 module Spree
   # Shared shape of the typed adjustment rows (TaxLine, Discount, Fee):
   # dual-FK cart/order owner (exactly one), consolidated +metadata+ JSON
-  # column, money display and localized amount parsing.
+  # column, money display and strict amount parsing.
   module TypedAdjustmentLine
     extend ActiveSupport::Concern
 
     included do
+      include Spree::CanonicalDecimals
+
+      canonical_decimals :amount
       attribute :metadata, default: -> { {} }
 
       belongs_to :order, class_name: 'Spree::Order', optional: true
@@ -38,10 +41,6 @@ module Spree
       end
     end
 
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
     def currency
       owner&.currency
     end
@@ -49,7 +48,7 @@ module Spree
     private
 
     def exactly_one_owner
-      errors.add(:base, :exactly_one_of_cart_or_order, message: Spree.t('errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
+      errors.add(:base, :exactly_one_of_cart_or_order, message: I18n.t('spree.errors.messages.exactly_one_of_cart_or_order')) unless [order, cart].compact.one?
     end
   end
 end

data/app/models/concerns/spree/typed_associations.rb

@@ -53,7 +53,7 @@ module Spree
 
     def reconcile_typed_association(association, rows)
       collection = public_send(association)
-      kept_ids = rows.filter_map { |row| save_typed_association_row(collection, row) }
+      kept_ids = rows.each_with_index.filter_map { |row, index| save_typed_association_row(collection, row, "/#{association.to_s.split('_').last}/#{index}") }
       if kept_ids.any? || rows.empty?
         collection.where.not(id: kept_ids).destroy_all
         # `where.not(...).destroy_all` deletes the dropped rows from the DB but
@@ -64,7 +64,8 @@ module Spree
       end
     end
 
-    def save_typed_association_row(collection, row)
+    # @param pointer [String] where the row sits in the request, e.g. `/rules/1`
+    def save_typed_association_row(collection, row, pointer)
       record = find_or_build_typed_association_row(collection, row)
       return nil unless record
 
@@ -78,12 +79,10 @@ module Spree
       deferred_ids, scalar_attrs = attrs.partition { |k, _| record.new_record? && k.to_s.end_with?('_ids') }
       record.assign_attributes(scalar_attrs.to_h) if scalar_attrs.any?
 
-      preferences&.each do |key, value|
-        next unless record.has_preference?(key.to_sym)
-
-        record.set_preference(key.to_sym, decode_preference_value(key, value))
+      record.assign_preferences(preferences, pointer: "#{pointer}/preferences") if preferences
+      if calculator.present? && record.respond_to?(:assign_calculator_attributes)
+        record.assign_calculator_attributes(calculator, pointer: "#{pointer}/calculator")
       end
-      record.assign_calculator_attributes(calculator) if calculator.present? && record.respond_to?(:assign_calculator_attributes)
 
       # Always save — `record.changed?` doesn't reflect preferences
       # (serialized hash) or calculator association changes.
@@ -93,17 +92,12 @@ module Spree
       record.save! if record.changed?
 
       record.id
-    end
-
-    # Decode `*_ids` array preferences (`customer_group_ids`, `user_ids`,
-    # …) from prefixed strings to raw PKs. Plain-scalar / non-id
-    # preferences pass through unchanged.
-    def decode_preference_value(key, value)
-      return value unless key.to_s.end_with?('_ids') && value.is_a?(Array)
-
-      value.map do |v|
-        Spree::PrefixedId.prefixed_id?(v) ? Spree::PrefixedId.decode_prefixed_id(v) : v
-      end
+    rescue ActiveRecord::RecordInvalid => e
+      # A row saved from the owner's `after_save` fails inside the owner's own
+      # save, and a plain `save` swallows the exception — so its errors are
+      # copied onto the owner, or the caller learns only that something failed.
+      e.record.errors.full_messages.each { |message| errors.add(:base, message) }
+      raise
     end
 
     def find_or_build_typed_association_row(collection, row)

data/app/models/concerns/spree/vat_price_calculation.rb

@@ -1,6 +1,9 @@
 module Spree
   # Restates a VAT-inclusive price for a customer in another country: the
   # home-country VAT comes out, the destination's goes on.
+  #
+  # The including class answers +currency+, which the restated amount is
+  # rounded to.
   module VatPriceCalculation
     # Cheapest test first: a domestic sale needs no restatement whatever the
     # provider is, so the provider lookup (a constantize and an instantiation) is
@@ -11,7 +14,7 @@ module Spree
       return amount if amount.nil? || !outside_default_vat_zone?(price_options)
       return amount unless restatement_available?(price_options)
 
-      round_to_two_places(add_foreign_vat_for(amount, price_options))
+      Spree::Money::Rounding.to_currency(add_foreign_vat_for(amount, price_options), currency)
     end
 
     private
@@ -66,7 +69,7 @@ module Spree
         lookup[:country] = country_from(price_options)
       end
 
-      Spree::TaxRate.included_tax_amount_for(lookup).to_f
+      Spree::TaxRate.included_tax_amount_for(lookup).to_d
     end
 
     # +current_price_options+ is documented as an override point, so an app may
@@ -92,9 +95,5 @@ module Spree
 
       @default_tax_country = Spree::Current.store&.default_country
     end
-
-    def round_to_two_places(amount)
-      Spree::Money::Rounding.quantize(amount, 2)
-    end
   end
 end

data/app/models/spree/address.rb

@@ -7,7 +7,7 @@ module Spree
     include Spree::HasCustomFields
     include Spree::Metadata
 
-    serialize :preferences, type: Hash, coder: YAML, default: {}
+    serialize :preferences, coder: Spree::Metadata::HashSerializer, default: {}
 
     NO_ZIPCODE_ISO_CODES ||= [
       'AO', 'AG', 'AW', 'BS', 'BZ', 'BJ', 'BM', 'BO', 'BW', 'BF', 'BI', 'CM', 'CF', 'KM', 'CG',
@@ -27,6 +27,10 @@ module Spree
     # those attributes depending of the logic of their applications
     ADDRESS_FIELDS = %w(first_name last_name company address1 address2 city state postal_code country phone)
 
+    # The columns a delivery quote reads. A change to anything else (a phone
+    # number, the recipient's name) leaves the parcel going where it was.
+    DESTINATION_FIELDS = %w(address1 address2 city state_code postal_code country_code).freeze
+
     # Beyond identity and ownership, three groups are excluded because they
     # cannot tell two addresses apart. Latitude and longitude are derived from
     # the address, so an entry whose geocoding has already run would otherwise
@@ -202,7 +206,7 @@ module Spree
       scope.first
     end
 
-    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS + %w[country_code state_code]
+    self.whitelisted_ransackable_attributes = ADDRESS_FIELDS - %w[country state] + %w[country_code state_code]
     self.whitelisted_ransackable_associations = %w[owner]
 
     def self.required_fields
@@ -379,6 +383,12 @@ module Spree
       attributes.except(*EXCLUDED_KEYS_FOR_COMPARISON)
     end
 
+    # @return [Boolean] whether the last save moved this address somewhere
+    #   else, as opposed to correcting who receives the parcel
+    def saved_change_to_destination?
+      saved_changes.keys.intersect?(DESTINATION_FIELDS)
+    end
+
     # A country alone doesn't make an address — a new one is pre-filled with the
     # store's default, so both the code and the association are ignored here.
     def empty?

data/app/models/spree/adjusters/largest_remainder.rb

@@ -1,6 +1,7 @@
 module Spree
   module Adjusters
-    # Largest-remainder apportionment of an integer cent total across weights.
+    # Largest-remainder apportionment of an integer total, in the currency's
+    # minor units, across weights.
     # Shared by promotion order-level distribution and manual admin discounts
     # so both split identically (sum of shares always equals the total).
     module LargestRemainder
@@ -19,6 +20,18 @@ module Spree
         end
         shares
       end
+
+      # Splits an amount across weights in the currency's minor units, so the
+      # shares are amounts that sum exactly to the one given.
+      #
+      # @param amount [BigDecimal]
+      # @param weights [Array<Numeric>] proportional bases (sum must be > 0)
+      # @param currency [String]
+      # @return [Array<BigDecimal>]
+      def apportion(amount, weights, currency)
+        units = Spree::Money::Rounding.to_minor_units(amount, currency)
+        largest_remainder_shares(units, weights).map { |share| Spree::Money::Rounding.from_minor_units(share, currency) }
+      end
     end
   end
 end

data/app/models/spree/adjusters/promotion.rb

@@ -65,22 +65,8 @@ module Spree
         end
       end
 
-      # The owner's PERSISTED coupon code keeps its promotion in candidacy
-      # even before it ever applied — the discount activates on the exact
-      # recalculation where the cart first qualifies, and deactivates the
-      # same way (Shopify-parity for cart-level discount codes). In-memory
-      # assignments deliberately don't participate: unsaved codes belong to
-      # the explicit PromotionHandler::Coupon path.
       def coupon_promotions
-        return [] unless order.class.respond_to?(:column_names) && order.class.column_names.include?('coupon_code')
-
-        code = order.read_attribute(:coupon_code)
-        return [] if code.blank?
-
-        promotion = order.store.promotions.active.with_coupon_code(code)
-        return [] if promotion.nil? || promotion.usage_limit_exceeded?(order)
-
-        [promotion]
+        Spree::Promotion.held_by_saved_coupon_code(order)
       end
 
       # A coupon promotion that produced rows becomes an applied promotion —
@@ -154,7 +140,7 @@ module Spree
         end
       end
 
-      # Largest-remainder distribution (in cents) of the order-wide winner over
+      # Largest-remainder distribution (in minor units) of the order-wide winner over
       # each line's remaining discounted base, so shares always sum exactly to
       # the promotion amount and no line goes below zero.
       def distribute_over_line_items(chosen)
@@ -163,11 +149,10 @@ module Spree
         bases_sum = bases.sum
         return if bases_sum <= 0
 
-        total_cents = [chosen[:amount].abs, bases_sum].min * 100
-        shares = Spree::Adjusters::LargestRemainder.largest_remainder_shares(total_cents.round, bases)
+        shares = Spree::Adjusters::LargestRemainder.apportion([chosen[:amount].abs, bases_sum].min, bases, order.currency)
 
         line_items.each_with_index do |line_item, index|
-          amount = -BigDecimal(shares[index]) / 100
+          amount = -shares[index]
           next if amount.zero?
 
           persist_discount(line_item, chosen, amount)

data/app/models/spree/allowed_origin.rb

@@ -10,7 +10,9 @@ module Spree
 
     include Spree::SingleStoreResource
 
-    belongs_to :store, class_name: 'Spree::Store'
+    self.whitelisted_ransackable_attributes = %w[origin]
+    search_by :origin
+
 
     validates :origin, presence: true
     validates :origin, uniqueness: { scope: [:store_id, *spree_base_uniqueness_scope] }

data/app/models/spree/api_key.rb

@@ -44,7 +44,6 @@ module Spree
       publishable? ? token : @plaintext_token
     end
 
-    belongs_to :store, class_name: 'Spree::Store'
     # Optional single-channel binding for publishable keys. A bound key
     # server-assigns the request's channel (see Api::V3::ChannelResolution),
     # making channel identity unforgeable instead of client-asserted via the
@@ -162,23 +161,23 @@ module Spree
       return if invalid.empty?
 
       errors.add(:scopes, :unknown_scopes, scopes: invalid.join(', '),
-                 message: Spree.t('errors.messages.unknown_scopes', scopes: invalid.join(', ')))
+                 message: I18n.t('spree.errors.messages.unknown_scopes', scopes: invalid.join(', ')))
     end
 
     def scopes_immutable
-      errors.add(:scopes, :api_key_scopes_immutable, message: Spree.t(:api_key_scopes_immutable))
+      errors.add(:scopes, :api_key_scopes_immutable, message: I18n.t('spree.api_key_scopes_immutable'))
     end
 
     def channel_binding_valid
       if secret?
-        errors.add(:channel, :api_key_channel_publishable_only, message: Spree.t(:api_key_channel_publishable_only))
+        errors.add(:channel, :api_key_channel_publishable_only, message: I18n.t('spree.api_key_channel_publishable_only'))
       elsif channel && channel.store_id != store_id
-        errors.add(:channel, :api_key_channel_must_belong_to_store, message: Spree.t(:api_key_channel_must_belong_to_store))
+        errors.add(:channel, :api_key_channel_must_belong_to_store, message: I18n.t('spree.api_key_channel_must_belong_to_store'))
       end
     end
 
     def channel_immutable
-      errors.add(:channel, :api_key_channel_immutable, message: Spree.t(:api_key_channel_immutable))
+      errors.add(:channel, :api_key_channel_immutable, message: I18n.t('spree.api_key_channel_immutable'))
     end
 
     # Generates the token on creation. For publishable keys, stores the raw token

data/app/models/spree/authentication/strategies/oidc_strategy.rb

@@ -129,7 +129,7 @@ module Spree
         # Password login is not available through an OIDC provider — the browser
         # redirect is the only entry point.
         def authenticate
-          failure(Spree.t('errors.messages.oidc_requires_redirect'))
+          failure(I18n.t('spree.errors.messages.oidc_requires_redirect'))
         end
 
         # Completes the login started by +#authorization_url+: exchanges the
@@ -138,13 +138,13 @@ module Spree
         # @return [Spree::ServiceModule::Result]
         def callback
           code = params[:code]
-          return authentication_failure(Spree.t('errors.messages.oidc_missing_code')) if code.blank?
+          return authentication_failure(I18n.t('spree.errors.messages.oidc_missing_code')) if code.blank?
 
           claims = verify_id_token(exchange_code_for_tokens(code).fetch('id_token'))
           resolve_user(claims)
         rescue StandardError => e
           Rails.logger.error("[Spree] OIDC callback failed for #{config[:label] || config[:issuer]}: #{e.message}")
-          authentication_failure(Spree.t('errors.messages.oidc_authentication_failed'))
+          authentication_failure(I18n.t('spree.errors.messages.oidc_authentication_failed'))
         end
 
         # True when the last +#callback+ failed because no account here is
@@ -168,7 +168,7 @@ module Spree
         #    every member of a corporate tenant would become store staff.
         def resolve_user(claims)
           subject = claims['sub']
-          return authentication_failure(Spree.t('errors.messages.oidc_authentication_failed')) if subject.blank?
+          return authentication_failure(I18n.t('spree.errors.messages.oidc_authentication_failed')) if subject.blank?
 
           identity = Spree::UserIdentity.find_by(
             provider: registry_key,
@@ -191,7 +191,7 @@ module Spree
 
         def not_provisioned_failure
           @account_not_provisioned = true
-          failure(Spree.t('errors.messages.oidc_account_not_provisioned'))
+          failure(I18n.t('spree.errors.messages.oidc_account_not_provisioned'))
         end
 
         # Only an email the provider asserts as verified may claim an existing

data/app/models/spree/base.rb

@@ -9,6 +9,7 @@ class Spree::Base < ApplicationRecord
   include Spree::HasNumber
   include Spree::HasIsoGeography
   include Spree::TypedAssociations
+  include Spree::SignedIdAttachments
   include Spree::ValidatesStoreUniqueness
 
   # Extra writable attributes contributed by extensions, appended to the v3
@@ -23,24 +24,20 @@ class Spree::Base < ApplicationRecord
   # rather than assigning, so extensions don't clobber each other.
   class_attribute :additional_permitted_attributes, instance_writer: false, default: [].freeze
 
+  # The Seller API's counterpart, kept separate because sellers write a
+  # narrower set than operators: an attribute an extension makes writable for
+  # admins stays admin-only unless it is also declared here.
+  #
+  #   Spree::Product.additional_seller_permitted_attributes += [:brand_id]
+  class_attribute :additional_seller_permitted_attributes, instance_writer: false, default: [].freeze
+
   # Backfills preferences added to the class after this row was last saved, so
-  # a reader never sees nil for a newly defined preference. Assigning
-  # unconditionally would dirty every record on load: `preferences` is a
-  # YAML-serialized Hash, so the dirty check compares the serialized string and
-  # the merge reorders keys even when nothing changed — which is enough to make
-  # `with_lock` refuse the record ("unpersisted changes").
+  # a reader never sees nil for a newly defined preference. Only missing keys
+  # are assigned: assigning unconditionally would dirty every record on load,
+  # which is enough to make `with_lock` refuse the record ("unpersisted
+  # changes").
   after_initialize do
-    if has_attribute?(:preferences) && !preferences.nil?
-      missing = default_preferences.except(*preferences.keys)
-      self.preferences = preferences.merge(missing) if missing.any?
-    end
-  end
-
-  # only for backwards compatibility with Kaminari
-  if defined?(Kaminari) && Kaminari.config.page_method_name != :page
-    def self.page(num)
-      send Kaminari.config.page_method_name, num
-    end
+    backfill_default_preferences if has_attribute?(:preferences) && !preferences.nil?
   end
 
   self.abstract_class = true
@@ -72,6 +69,18 @@ class Spree::Base < ApplicationRecord
     true
   end
 
+  # Whether to answer from an association's rows rather than a query of its
+  # own (a SUM, an EXISTS). True when the rows are loaded already, or when
+  # this record came from a list loaded with +preload_associations_lazily+:
+  # loading them then fetches the rows for the whole list in one query, where
+  # an aggregate would run once per record.
+  #
+  # @param name [Symbol] the association
+  # @return [Boolean]
+  def read_association_in_memory?(name)
+    association(name).loaded? || lazy_preload_context.present?
+  end
+
   # @see Spree.mysql? — the single definition; this reads it so a model can
   #   branch without reaching for the connection itself.
   def mysql_adapter?
@@ -115,9 +124,10 @@ class Spree::Base < ApplicationRecord
   # read through the parent (a plain `Spree::Export` row, a factory that sets
   # `type` as an attribute, a query on the base relation).
   #
-  # Resolves against `available_types` where the class defines it, so an
-  # unrecognized column value passes through untouched rather than being
-  # constantized.
+  # Resolves against the class's type registry where it has one, so an
+  # unrecognized column value (an extension no longer installed) is never
+  # constantized — it is shortened the same way instead, never sent as a class
+  # name.
   #
   # @param type [String, nil] value of the STI `type` column
   # @return [String]
@@ -125,9 +135,49 @@ class Spree::Base < ApplicationRecord
     return api_type if type.blank?
 
     type = type.to_s
-    return type unless respond_to?(:available_types)
+    api_type_registry.find { |klass| klass.to_s == type }&.api_type || type.demodulize.underscore
+  end
+
+  # Inverse of {.api_type_for}: the STI `type` column value for a wire
+  # shorthand, or nil when no registered subclass answers to it. Lookup is
+  # registry-driven, so a request can never name a class outside the family.
+  #
+  # @param api_type [String, nil] e.g. `"orders"`
+  # @return [String, nil] e.g. `"Spree::Exports::Orders"`
+  def self.class_name_for_api_type(api_type)
+    return nil if api_type.blank?
+
+    api_type_registry.find { |klass| klass.api_type == api_type.to_s }&.to_s
+  end
 
-    available_types.find { |klass| klass.to_s == type }&.api_type || type
+  # The subclasses a typed family accepts — `registered_subclasses` for the
+  # preference-schema families, `available_types` for exports and imports.
+  #
+  # @return [Array<Class>]
+  def self.api_type_registry
+    if subclass_registry
+      registered_subclasses
+    elsif respond_to?(:available_types)
+      Array(available_types)
+    else
+      []
+    end
+  end
+
+  # How a filter on one of this model's columns turns the short name a client
+  # sends (`purchase_order`) into the class name the column stores, or nil
+  # when the column does not store class names. Covers the STI column of a
+  # typed family and polymorphic `*_type` columns; a model with another such
+  # column overrides this.
+  #
+  # @param attribute [String]
+  # @return [Proc, nil] short name → stored class name
+  def self.api_type_resolver(attribute)
+    if attribute == inheritance_column && api_type_registry.any?
+      ->(api_type) { class_name_for_api_type(api_type) }
+    elsif reflect_on_all_associations(:belongs_to).any? { |reflection| reflection.polymorphic? && reflection.foreign_type == attribute }
+      ->(api_type) { Spree::Base.polymorphic_type_for(api_type) }
+    end
   end
 
   # Shorthand for a *polymorphic* `*_type` column (`owner_type`,
@@ -138,10 +188,37 @@ class Spree::Base < ApplicationRecord
   #
   # @param type [String, Class, nil] value of the polymorphic type column
   # @return [String, nil]
+  #
+  # The configured customer and admin user classes always answer `customer`
+  # and `admin_user`, so a host app's own `User` class does not change the
+  # contract.
   def self.polymorphic_api_type(type)
     return nil if type.blank?
 
-    type.to_s.demodulize.underscore
+    type = type.to_s
+    return 'customer' if type == Spree.customer_class(constantize: false)
+    return 'admin_user' if type == Spree.admin_user_class(constantize: false)
+
+    type.demodulize.underscore
+  end
+
+  # Inverse of {.polymorphic_api_type}: the class name a polymorphic `*_type`
+  # column stores for a wire shorthand. Matches against `candidates` when the
+  # caller knows what the column may reference (always prefer that); otherwise
+  # against the configured customer and admin user classes, then the
+  # `Spree::` model of that name. Never constantizes the input.
+  #
+  # @param api_type [String, nil] e.g. `"purchase_order"`
+  # @param candidates [Array<Class, String>, nil] classes the column may hold
+  # @return [String, nil] e.g. `"Spree::PurchaseOrder"`
+  def self.polymorphic_type_for(api_type, candidates = nil)
+    token = api_type.to_s
+    return nil unless token.match?(/\A[a-z][a-z0-9_]*\z/)
+
+    candidates ||= [Spree.customer_class(constantize: false),
+                    Spree.admin_user_class(constantize: false),
+                    "Spree::#{token.camelize}"]
+    candidates.map(&:to_s).find { |name| polymorphic_api_type(name) == token }
   end
 
   # Prefixed id for a polymorphic reference, encoded from the columns without

data/app/models/spree/calculator/flat_percent_item_total.rb

@@ -1,15 +1,13 @@
-require_dependency 'spree/calculator'
-
 module Spree
   class Calculator::FlatPercentItemTotal < Calculator
     preference :flat_percent, :decimal, default: 0
 
     def self.description
-      Spree.t(:flat_percent)
+      I18n.t('spree.flat_percent')
     end
 
     def compute(object)
-      computed_amount = (object.amount * preferred_flat_percent / 100).round(2)
+      computed_amount = Spree::Money::Rounding.to_currency(object.amount * preferred_flat_percent / 100, object.try(:currency))
 
       # We don't want to cause the promotion adjustments to push the order into a negative total.
       if computed_amount > object.amount

data/app/models/spree/calculator/flat_rate.rb

@@ -1,13 +1,11 @@
-require_dependency 'spree/calculator'
-
 module Spree
   class Calculator::FlatRate < Calculator
-    preference :amount, :decimal, default: 0
-    preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+    preference :amount, :money, default: 0
+    preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
     preference :apply_only_on_full_priced_items, :boolean, default: false
 
     def self.description
-      Spree.t(:flat_rate_per_order)
+      I18n.t('spree.flat_rate_per_order')
     end
 
     def compute(object = nil)

data/app/models/spree/calculator/flexi_rate.rb

@@ -1,15 +1,13 @@
-require_dependency 'spree/calculator'
-
 module Spree
   class Calculator::FlexiRate < Calculator
-    preference :first_item,      :decimal, default: 0.0
-    preference :additional_item, :decimal, default: 0.0
+    preference :first_item,      :money, default: 0.0
+    preference :additional_item, :money, default: 0.0
     preference :max_items,       :integer, default: 0
-    preference :currency,        :string,  default: -> { Spree::Store.default.default_currency }
+    preference :currency,        :string,  format: :currency, default: -> { Spree::Store.default.default_currency }
     preference :apply_only_on_full_priced_items, :boolean, default: false
 
     def self.description
-      Spree.t(:flexible_rate)
+      I18n.t('spree.flexible_rate')
     end
 
     def self.available?(_object)

data/app/models/spree/calculator/percent_on_line_item.rb

@@ -5,13 +5,13 @@ module Spree
       preference :apply_only_on_full_priced_items, :boolean, default: false
 
       def self.description
-        Spree.t(:percent_per_item)
+        I18n.t('spree.percent_per_item')
       end
 
       def compute(object)
         return 0 if preferred_apply_only_on_full_priced_items && object.variant.compare_at_amount_in(object.currency).present?
 
-        computed_amount = (object.amount * preferred_percent / 100).round(2)
+        computed_amount = Spree::Money::Rounding.to_currency(object.amount * preferred_percent / 100, object.currency)
 
         # We don't want to cause the promotion adjustments to push the order into a negative total.
         if computed_amount > object.amount

data/app/models/spree/calculator/price_sack.rb

@@ -1,14 +1,12 @@
-require_dependency 'spree/calculator'
-
 module Spree
   class Calculator::PriceSack < Calculator
-    preference :minimal_amount, :decimal, default: 0
-    preference :normal_amount, :decimal, default: 0
-    preference :discount_amount, :decimal, default: 0
-    preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+    preference :minimal_amount, :money, default: 0
+    preference :normal_amount, :money, default: 0
+    preference :discount_amount, :money, default: 0
+    preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
     def self.description
-      Spree.t(:price_sack)
+      I18n.t('spree.price_sack')
     end
 
     # as object we always get line items, as calculable we have Coupon, ShippingMethod

data/app/models/spree/calculator/shipping/digital_delivery.rb

@@ -1,15 +1,13 @@
-require_dependency 'spree/shipping_calculator'
-
 module Spree
   module Calculator::Shipping
     class DigitalDelivery < ShippingCalculator
       include Spree::Calculator::CurrencyAmounts
 
-      preference :amount, :decimal, default: 0
-      preference :currency, :string, default: -> { Spree::Store.default.default_currency }
+      preference :amount, :money, default: 0
+      preference :currency, :string, format: :currency, default: -> { Spree::Store.default.default_currency }
 
       def self.description
-        Spree.t('digital.digital_delivery')
+        I18n.t('spree.digital.digital_delivery')
       end
 
       def compute_package(package = nil)

data/app/models/spree/calculator/shipping/flat_percent_item_total.rb

@@ -1,21 +1,21 @@
-require_dependency 'spree/shipping_calculator'
-
 module Spree
   module Calculator::Shipping
     class FlatPercentItemTotal < ShippingCalculator
       preference :flat_percent, :decimal, default: 0
 
       def self.description
-        Spree.t(:flat_percent)
+        I18n.t('spree.flat_percent')
       end
 
       def compute_package(package)
-        compute_from_price(total(package.contents))
+        compute_from_price(total(package.contents), package.currency)
       end
 
-      def compute_from_price(price)
-        value = price * BigDecimal(preferred_flat_percent.to_s) / 100.0
-        (value * 100).round.to_f / 100
+      # @param price [BigDecimal]
+      # @param currency [String, nil] the amount is rounded to its minor unit
+      # @return [BigDecimal]
+      def compute_from_price(price, currency = nil)
+        Spree::Money::Rounding.to_currency(price * BigDecimal(preferred_flat_percent.to_s) / 100, currency)
       end
     end
   end